{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ba499e4c-ae02-49f6-b06a-dea0e69ed4ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set size: 10000\n",
      "Training set size: 60000\n",
      "Number of training samples: 43360\n",
      "Number of cross-validation samples: 10850\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "label_size = 18 # Label size\n",
    "ticklabel_size = 14 # Tick label size\n",
    "\n",
    "class FlattenTransform:\n",
    "    def __call__(self, tensor):\n",
    "        ''' \n",
    "        Flatten tensor into an 1-D vector\n",
    "        '''\n",
    "        return tensor.view(-1)\n",
    "    \n",
    "# Define a transform to normalize the data\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToTensor(),\n",
    "    FlattenTransform()\n",
    "])\n",
    "\n",
    "# Load test data from the MNIST\n",
    "testset = torchvision.datasets.MNIST(root='./Data', train=False, download=False, transform=transform)\n",
    "print(f\"Test set size: {len(testset)}\")\n",
    "\n",
    "# Load training data from the MNIST\n",
    "trainset = torchvision.datasets.MNIST(root='./Data', train=True, download=False, transform=transform)\n",
    "print(f\"Training set size: {len(trainset)}\")\n",
    "\n",
    "# Rate of trX and cvX\n",
    "tr_cv_rate = 0.8\n",
    "\n",
    "# Create a list to store indices for each class\n",
    "class_indices = [[] for _ in range(10)]  # 10 classes in MNIST\n",
    "\n",
    "# Populate class_indices\n",
    "for idx, (_, label) in enumerate(trainset):\n",
    "    class_indices[label].append(idx)\n",
    "\n",
    "# Calculate the number of samples for each class in training and validation sets\n",
    "train_size_per_class = int(tr_cv_rate * min(len(indices) for indices in class_indices))\n",
    "val_size_per_class = min(len(indices) for indices in class_indices) - train_size_per_class\n",
    "\n",
    "# Create balanced train and validation sets\n",
    "train_indices = []\n",
    "val_indices = []\n",
    "for indices in class_indices:\n",
    "    train_indices.extend(indices[:train_size_per_class])\n",
    "    val_indices.extend(indices[train_size_per_class:train_size_per_class + val_size_per_class])\n",
    "\n",
    "# Create Subset datasets\n",
    "from torch.utils.data import Subset\n",
    "trX = Subset(trainset, train_indices)\n",
    "cvX = Subset(trainset, val_indices)\n",
    "\n",
    "print(f\"Number of training samples: {len(trX)}\")\n",
    "print(f\"Number of cross-validation samples: {len(cvX)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "07373296-4538-44c9-9fba-e8c7c088fb31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input_size is 784\n",
      "tensor([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],\n",
      "        [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],\n",
      "        [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.]])\n"
     ]
    }
   ],
   "source": [
    "batch_size = 42 # Define training batch\n",
    "def one_hot_collate(batch):\n",
    "    data = torch.stack([item[0] for item in batch])\n",
    "    labels = torch.tensor([item[1] for item in batch])\n",
    "    one_hot_labels = torch.zeros(labels.size(0), 10)  # 10 classes in MNIST\n",
    "    one_hot_labels.scatter_(1, labels.unsqueeze(1), 1)\n",
    "    return data, one_hot_labels\n",
    "\n",
    "trLoader = torch.utils.data.DataLoader(trX, batch_size=batch_size, shuffle=True, num_workers=0, collate_fn=one_hot_collate)\n",
    "cvLoader = torch.utils.data.DataLoader(cvX, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=one_hot_collate)\n",
    "teLoader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=one_hot_collate)\n",
    "\n",
    "# Get a batch of training data\n",
    "dataiter = iter(trLoader)\n",
    "data, labels = next(dataiter)\n",
    "\n",
    "input_size = data[0].numpy().shape[0]\n",
    "print(f'Input_size is {input_size}')\n",
    "print(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "faa29054-ff53-44c8-b256-1527dbb6f31c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FNN(\n",
      "  (fc1): Linear(in_features=784, out_features=10, bias=True)\n",
      "  (relu1): ReLU()\n",
      "  (fc2): Linear(in_features=10, out_features=10, bias=True)\n",
      "  (relu2): ReLU()\n",
      "  (fc3): Linear(in_features=10, out_features=10, bias=True)\n",
      "  (softmax): Softmax(dim=1)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "class FNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, num_classes):\n",
    "        super(FNN, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_size, hidden_size)\n",
    "        self.relu1 = nn.ReLU()\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.relu2 = nn.ReLU()\n",
    "        self.fc3 = nn.Linear(hidden_size, num_classes)\n",
    "        self.softmax = nn.Softmax(dim=1)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu1(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu2(x)\n",
    "        x = self.fc3(x)\n",
    "        out = self.softmax(x)\n",
    "        return out\n",
    "\n",
    "# Define the model parameters\n",
    "hidden_size = 10\n",
    "num_classes = 10  # MNIST has 10 classes (digits 0-9)\n",
    "\n",
    "# Instantiate the model\n",
    "model = FNN(input_size, hidden_size, num_classes)\n",
    "print(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6a294ec-e26c-411d-92cc-d3d031f3bf83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/20], Train Loss: 1.8461, CV Loss: 1.7339\n",
      "Epoch [2/20], Train Loss: 1.7220, CV Loss: 1.7202\n",
      "Epoch [3/20], Train Loss: 1.7131, CV Loss: 1.7173\n",
      "Epoch [4/20], Train Loss: 1.7081, CV Loss: 1.7132\n",
      "Epoch [5/20], Train Loss: 1.7046, CV Loss: 1.7110\n",
      "Epoch [6/20], Train Loss: 1.7013, CV Loss: 1.7100\n",
      "Epoch [7/20], Train Loss: 1.6993, CV Loss: 1.7085\n",
      "Epoch [8/20], Train Loss: 1.6977, CV Loss: 1.7088\n",
      "Epoch [9/20], Train Loss: 1.6960, CV Loss: 1.7058\n",
      "Epoch [10/20], Train Loss: 1.6949, CV Loss: 1.7058\n",
      "Epoch [11/20], Train Loss: 1.6937, CV Loss: 1.7069\n",
      "Epoch [12/20], Train Loss: 1.6928, CV Loss: 1.7051\n",
      "Epoch [13/20], Train Loss: 1.6915, CV Loss: 1.7038\n",
      "Epoch [14/20], Train Loss: 1.6909, CV Loss: 1.7034\n",
      "Epoch [15/20], Train Loss: 1.6896, CV Loss: 1.7060\n",
      "Epoch [16/20], Train Loss: 1.6888, CV Loss: 1.7042\n",
      "Epoch [17/20], Train Loss: 1.6879, CV Loss: 1.7028\n",
      "Epoch [18/20], Train Loss: 1.6872, CV Loss: 1.7030\n",
      "Epoch [19/20], Train Loss: 1.6866, CV Loss: 1.7019\n",
      "Epoch [20/20], Train Loss: 1.6864, CV Loss: 1.7011\n"
     ]
    }
   ],
   "source": [
    "# Define loss function and optimizer\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(model.parameters())\n",
    "\n",
    "# Lists to store losses\n",
    "train_losses = []\n",
    "cv_losses = []\n",
    "\n",
    "# Number of epochs\n",
    "num_epochs = 20\n",
    "\n",
    "for epoch in range(num_epochs):\n",
    "    model.train()\n",
    "    batch_losses = []\n",
    "    \n",
    "    for batch_x, batch_y in trLoader:\n",
    "        # Forward pass\n",
    "        outputs = model(batch_x)\n",
    "        loss = criterion(outputs, batch_y)\n",
    "        \n",
    "        # Backward pass and optimize\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        batch_losses.append(loss.item())\n",
    "    \n",
    "    # Calculate average training loss for this epoch\n",
    "    avg_train_loss = sum(batch_losses) / len(batch_losses)\n",
    "    train_losses.append(avg_train_loss)\n",
    "    \n",
    "    # Evaluate on cross-validation set\n",
    "    model.eval()\n",
    "    cv_batch_losses = []\n",
    "    with torch.no_grad():\n",
    "        for cv_x, cv_y in cvLoader:\n",
    "            cv_outputs = model(cv_x)\n",
    "            cv_loss = criterion(cv_outputs, cv_y)\n",
    "            cv_batch_losses.append(cv_loss.item())\n",
    "    \n",
    "    avg_cv_loss = sum(cv_batch_losses) / len(cv_batch_losses)\n",
    "    cv_losses.append(avg_cv_loss)\n",
    "    \n",
    "    print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {avg_train_loss:.4f}, CV Loss: {avg_cv_loss:.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4d4ebbcc-7f82-449a-bb3b-7d3513ac980e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on training set: 77.65%\n",
      "Accuracy on cross-validation set: 76.13%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAHUCAYAAADWedKvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/K0lEQVR4nO3deVhUZcMG8PvMMAvrsMgu4I65kWaZmrulaKRpamoqpq222qJWbqlZltubZW+mkmVmrm9fue+VmlpppmaaCCgoCrLDMMv5/hjmwMCwDwwD9++6zsWcM88585zxaNw9myCKoggiIiIiIiKqFpm9K0BERERERFQfMFwRERERERHZAMMVERERERGRDTBcERERERER2QDDFRERERERkQ0wXBEREREREdkAwxUREREREZENMFwRERERERHZAMMVERERERGRDTBcEVGDIQhChbZDhw5V63PmzJkDQRCqdO6hQ4dsUoe6Ljo6Gk2aNKlQWaPRiK+++gr9+/dHo0aNoFAo4Ofnh4cffhj/93//B6PRWLOVraYzZ85AEARMnz691DKXLl2CIAh46aWXKnxda89Z79690bt373LPvXr1KgRBQExMTIU/z+z8+fOYM2cOrl69WuK9yvy52pogCHjhhRfs8tlERGZO9q4AEVFtOXbsmMX+vHnzcPDgQRw4cMDieJs2bar1OZMnT8bAgQOrdG6nTp1w7NixatehvsjLy8PQoUOxZ88ePP7441i5ciUCAgJw69Yt7Nq1CyNGjMDGjRsxZMgQe1e1VBEREbjnnnuwbt06LFiwAHK5vESZtWvXAgAmTZpUrc/69NNPq3V+RZw/fx5z585F7969SwSpmTNn4uWXX67xOhAR1VUMV0TUYNx///0W+76+vpDJZCWOF5eTkwMXF5cKf07jxo3RuHHjKtXRw8Oj3Po0JFOnTsXu3bvx5ZdfYvz48RbvDRs2DG+88QZyc3NLPV+n00EQBDg52fc/d5MmTcLzzz+PnTt34uGHH7Z4z2AwYN26dbjnnnsQERFRrc+xdyhv3ry5XT+fiMje2C2QiKiI3r17o127djhy5Ai6desGFxcXPPnkkwCAjRs34qGHHkJgYCCcnZ1x1113Yfr06cjOzra4hrXuWk2aNMHDDz+MXbt2oVOnTnB2dkbr1q2xZs0ai3LWugVGR0fDzc0Nly9fxqBBg+Dm5oaQkBC89tpr0Gq1Fudfu3YNjz32GNzd3eHp6YmxY8fi5MmTFeoCduvWLTz//PNo06YN3Nzc4Ofnh759++Knn36yKGfuUvbRRx9hyZIlaNq0Kdzc3NC1a1ccP368xHVjYmIQHh4OlUqFu+66C+vWrSuzHmY3btzAF198gQEDBpQIVmYtW7ZEhw4dABR+d1999RVee+01BAcHQ6VS4fLlywCANWvWICIiAmq1Gt7e3nj00Udx4cIFi+tduXIFjz/+OIKCgqBSqeDv749+/frh9OnTUpkDBw6gd+/e8PHxgbOzM0JDQzF8+HDk5OSUei9jxoyBs7Oz1EJV1J49e3D9+vVKP2fWWOsWmJiYiJEjR8Ld3R0ajQajRo3CjRs3Spx76tQpPP7442jSpAmcnZ3RpEkTjB49GnFxcVKZmJgYjBgxAgDQp08fqSut+dmy1i0wLy8PM2bMQNOmTaFUKhEcHIwpU6YgLS3NolxF/45UR2pqKp5//nkEBwdDqVSiWbNmePvtt0v8Pdq0aRO6dOkCjUYDFxcXNGvWTPrzAUxdVefPn4/w8HA4OzvD09MTHTp0wPLly21WVyJyTGy5IiIqJikpCU888QTefPNNvPfee5DJTP8f6tKlSxg0aBBeeeUVuLq64u+//8YHH3yAEydOlOhaaM2ZM2fw2muvYfr06fD398cXX3yBSZMmoUWLFujZs2eZ5+p0OjzyyCOYNGkSXnvtNRw5cgTz5s2DRqPBrFmzAADZ2dno06cPUlNT8cEHH6BFixbYtWsXRo0aVaH7Tk1NBQDMnj0bAQEByMrKwrZt29C7d2/s37+/xC/tn3zyCVq3bo1ly5YBMHUJGzRoEGJjY6HRaACYfhmfOHEihgwZgsWLFyM9PR1z5syBVquVvtfSHDx4EDqdDkOHDq1Q/c1mzJiBrl274rPPPoNMJoOfnx8WLlyIt956C6NHj8bChQuRkpKCOXPmoGvXrjh58iRatmwJABg0aBAMBgMWLVqE0NBQ3L59G0ePHpWCwNWrVzF48GD06NEDa9asgaenJ65fv45du3YhPz+/1BZOjUaD4cOHY+PGjbh16xZ8fX2l99auXQu1Wo0xY8YAqP5zVlRubi769++PxMRELFy4EK1atcKPP/5o9Zm4evUqwsPD8fjjj8Pb2xtJSUlYuXIl7r33Xpw/fx6NGjXC4MGD8d577+Gtt97CJ598gk6dOgEovcVKFEUMHToU+/fvx4wZM9CjRw/8+eefmD17No4dO4Zjx45BpVJJ5avzd6Q8eXl56NOnD/7991/MnTsXHTp0wE8//YSFCxfi9OnT+PHHHwGYug+PGjUKo0aNwpw5c6BWqxEXF2fx3S9atAhz5szBO++8g549e0Kn0+Hvv/8uERiJqAESiYgaqAkTJoiurq4Wx3r16iUCEPfv31/muUajUdTpdOLhw4dFAOKZM2ek92bPni0W/+c1LCxMVKvVYlxcnHQsNzdX9Pb2Fp955hnp2MGDB0UA4sGDBy3qCUD87rvvLK45aNAgMTw8XNr/5JNPRADizp07Lco988wzIgBx7dq1Zd5TcXq9XtTpdGK/fv3ERx99VDoeGxsrAhDbt28v6vV66fiJEydEAOKGDRtEURRFg8EgBgUFiZ06dRKNRqNU7urVq6JCoRDDwsLK/Pz3339fBCDu2rWrQvU1f3c9e/a0OH7nzh3R2dlZHDRokMXx+Ph4UaVSiWPGjBFFURRv374tAhCXLVtW6mds3rxZBCCePn26QnWyVr8lS5ZIx1JSUkSVSiWOHTvW6jmVfc569eol9urVS9pfuXKlCED83//+Z1HuqaeeKveZ0Ov1YlZWlujq6iouX75cOr5p06YSz6jZhAkTLP5cd+3aJQIQFy1aZFFu48aNIgDx888/l45V9O9IaQCIU6ZMKfX9zz77zOrfow8++EAEIO7Zs0cURVH86KOPRABiWlpaqdd6+OGHxbvvvrvcOhFRw8NugURExXh5eaFv374ljl+5cgVjxoxBQEAA5HI5FAoFevXqBQAlupdZc/fddyM0NFTaV6vVaNWqlUW3q9IIgoCoqCiLYx06dLA49/Dhw3B3dy8xmcbo0aPLvb7ZZ599hk6dOkGtVsPJyQkKhQL79++3en+DBw+2mJzB3D3PXKeLFy8iMTERY8aMsegmGRYWhm7dulW4TpU1fPhwi/1jx44hNzcX0dHRFsdDQkLQt29f7N+/HwDg7e2N5s2b48MPP8SSJUvwxx9/lJiJ8O6774ZSqcTTTz+NL7/8EleuXCnx+QaDAXq9XtrM1+jVqxeaN29u0TVw/fr10Gq1Fl3OqvucFXXw4EG4u7vjkUcesThubiUrKisrC9OmTUOLFi3g5OQEJycnuLm5ITs7u9Kfa2Zu7Sn+3Y8YMQKurq7Sd29Wnb8jFamLq6srHnvsMYvj5rqZ63LvvfcCAEaOHInvvvsO169fL3Gt++67D2fOnMHzzz+P3bt3IyMjo9r1I6L6geGKiKiYwMDAEseysrLQo0cP/Prrr5g/fz4OHTqEkydPYuvWrQBQ5qQKZj4+PiWOqVSqCp3r4uICtVpd4ty8vDxpPyUlBf7+/iXOtXbMmiVLluC5555Dly5dsGXLFhw/fhwnT57EwIEDrdax+P2Yu3eZy6akpAAAAgICSpxr7Vhx5l+yY2NjK1R/s+J/fuZ6WPtzDQoKkt4XBAH79+/HgAEDsGjRInTq1Am+vr546aWXkJmZCcDU/W3fvn3w8/PDlClT0Lx5czRv3txirE2/fv2gUCikzRycBEHAk08+ibNnz+LUqVMATF0CmzZtij59+gCwzXNW/N6t/flb+/7HjBmDFStWYPLkydi9ezdOnDiBkydPwtfXt9KfW/TznZycLLpBAqbvIiAgQPruzarzd6QidQkICCgxHtLPzw9OTk5SXXr27Int27dDr9dj/PjxaNy4Mdq1a4cNGzZI58yYMQMfffQRjh8/jsjISPj4+KBfv37SnysRNVwcc0VEVIy1NaoOHDiAxMREHDp0SGpFAFCnxlj4+PjgxIkTJY5bm7zAmq+//hq9e/fGypUrLY6bg0VV6lPa51ekTn369IFCocD27dvx7LPPVvhzi//5meuRlJRUomxiYiIaNWok7YeFhWH16tUAgH/++Qffffcd5syZg/z8fHz22WcAgB49eqBHjx4wGAw4deoUPv74Y7zyyivw9/fH448/jv/+978W31nR60dHR2PWrFlYs2YNFAoF/vjjD8ybN0+qs62fs4o+E+np6fjhhx8we/Zsi/W4tFqtNBavqp+v1+tLjDMTRRE3btyQWolqg4+PD3799VeIomjxjCQnJ0Ov11v8OQ0ZMgRDhgyBVqvF8ePHsXDhQowZMwZNmjRB165d4eTkhKlTp2Lq1KlIS0vDvn378NZbb2HAgAFISEio1OyiRFS/sOWKiKgCzL+MFR18DwD//e9/7VEdq3r16oXMzEzs3LnT4vi3335bofMFQShxf3/++WeJ9cEqKjw8HIGBgdiwYQNEUZSOx8XF4ejRo+WeHxAQILWilDbD4L///os///yzzOt07doVzs7O+Prrry2OX7t2DQcOHEC/fv2snteqVSu88847aN++PX7//fcS78vlcnTp0gWffPIJAEhlwsPD0blzZ2krOnteUFAQBg4ciA0bNuCTTz6BTCbDhAkTpPdt/Zz16dMHmZmZ+P777y2Of/PNNxb7giBAFMUSn/vFF1/AYDBYHCveQlkW83db/LvfsmULsrOzS/3ua0K/fv2QlZWF7du3Wxw3P1vW6qJSqdCrVy988MEHAIA//vijRBlPT0889thjmDJlClJTU60urkxEDQdbroiIKqBbt27w8vLCs88+i9mzZ0OhUGD9+vU4c+aMvasmmTBhApYuXYonnngC8+fPR4sWLbBz507s3r0bAMqdne/hhx/GvHnzMHv2bPTq1QsXL17Eu+++i6ZNm0Kv11e6PjKZDPPmzcPkyZPx6KOP4qmnnkJaWhrmzJlToW6BgKmr4pUrVxAdHY3du3fj0Ucfhb+/P27fvo29e/di7dq1+Pbbb6XxXtZ4enpi5syZeOuttzB+/HiMHj0aKSkpmDt3LtRqNWbPng3AFCRfeOEFjBgxAi1btoRSqcSBAwfw559/Sq05n332GQ4cOIDBgwcjNDQUeXl50lTh/fv3r9A9TZo0CT/++KM0zXxISIj0nq2fs/Hjx2Pp0qUYP348FixYgJYtW2LHjh3SM2Hm4eGBnj174sMPP0SjRo3QpEkTHD58GKtXr4anp6dF2Xbt2gEAPv/8c7i7u0OtVqNp06ZWu/Q9+OCDGDBgAKZNm4aMjAx0795dmi2wY8eOGDduXJXuqzT//vsvNm/eXOJ4mzZtMH78eHzyySeYMGECrl69ivbt2+Pnn3/Ge++9h0GDBkl/frNmzcK1a9fQr18/NG7cGGlpaVi+fLnF2LeoqCi0a9cOnTt3hq+vL+Li4rBs2TKEhYVJM08SUQNl3/k0iIjsp7TZAtu2bWu1/NGjR8WuXbuKLi4uoq+vrzh58mTx999/LzHrWmmzBQ4ePLjENYvP7lbabIHF61na58THx4vDhg0T3dzcRHd3d3H48OHijh07rM4YV5xWqxVff/11MTg4WFSr1WKnTp3E7du3l5gBzjxb4IcffljiGgDE2bNnWxz74osvxJYtW4pKpVJs1aqVuGbNmhLXLIterxe//PJLsW/fvqK3t7fo5OQk+vr6ipGRkeI333wjGgwGURQLv7tNmzZZvc4XX3whdujQQVQqlaJGoxGHDBkinjt3Tnr/5s2bYnR0tNi6dWvR1dVVdHNzEzt06CAuXbpUmhXx2LFj4qOPPiqGhYWJKpVK9PHxEXv16iV+//33FboXURTF/Px80d/f3+rMdaJYvees+PMkiqJ47do1cfjw4RbPxNGjR0tcz1zOy8tLdHd3FwcOHCj+9ddfYlhYmDhhwgSLay5btkxs2rSpKJfLLa5j7c81NzdXnDZtmhgWFiYqFAoxMDBQfO6558Q7d+5YlKvo35HSACh1Mz+TKSkp4rPPPisGBgaKTk5OYlhYmDhjxgwxLy9Pus4PP/wgRkZGisHBwaJSqRT9/PzEQYMGiT/99JNUZvHixWK3bt3ERo0aiUqlUgwNDRUnTZokXr16tdx6ElH9Johikb4aRERU77z33nt45513EB8fj8aNG9u7OkRERPUWuwUSEdUjK1asAAC0bt0aOp0OBw4cwH/+8x888cQTDFZEREQ1jOGKiKgecXFxwdKlS3H16lVotVqEhoZi2rRpeOedd+xdNSIionqP3QKJiIiIiIhsgFOxExERERER2QDDFRERERERkQ0wXBEREREREdkAJ7Swwmg0IjExEe7u7hAEwd7VISIiIiIiOxFFEZmZmQgKCoJMVnbbFMOVFYmJiQgJCbF3NYiIiIiIqI5ISEgod1kThisr3N3dAZi+QA8PDzvXhoiIiIiI7CUjIwMhISFSRigLw5UV5q6AHh4eDFdERERERFSh4UKc0IKIiIiIiMgGGK6IiIiIiIhsgOGKiIiIiIjIBjjmioiIiKiBE0URer0eBoPB3lUhsguFQgG5XF7t6zBcERERETVg+fn5SEpKQk5Ojr2rQmQ3giCgcePGcHNzq9Z1GK6IiIiIGiij0YjY2FjI5XIEBQVBqVRWaEY0ovpEFEXcunUL165dQ8uWLavVgsVwRURERNRA5efnw2g0IiQkBC4uLvauDpHd+Pr64urVq9DpdNUKV5zQgoiIiKiBk8n4KyE1bLZqseXfJCIiIiIiIhtguCIiIiIiIrIBhisiIiIiavB69+6NV155pcLlr169CkEQcPr06RqrEzkehisiIiIichiCIJS5RUdHV+m6W7duxbx58ypcPiQkBElJSWjXrl2VPq+iGOIcC2cLJCIiIiKHkZSUJL3euHEjZs2ahYsXL0rHnJ2dLcrrdDooFIpyr+vt7V2pesjlcgQEBFTqHKr/2HJVx606cgUPLjmMmF9i7V0VIiIiqudEUUROvt4umyiKFapjQECAtGk0GgiCIO3n5eXB09MT3333HXr37g21Wo2vv/4aKSkpGD16NBo3bgwXFxe0b98eGzZssLhu8W6BTZo0wXvvvYcnn3wS7u7uCA0Nxeeffy69X7xF6dChQxAEAfv370fnzp3h4uKCbt26WQQ/AJg/fz78/Pzg7u6OyZMnY/r06bj77rur9OcFAFqtFi+99BL8/PygVqvxwAMP4OTJk9L7d+7cwdixY+Hr6wtnZ2e0bNkSa9euBWCaiv+FF15AYGAg1Go1mjRpgoULF1a5LsSWqzovI0+HS8lZ+Cc5y95VISIionouV2dAm1m77fLZ598dABelbX41nTZtGhYvXoy1a9dCpVIhLy8P99xzD6ZNmwYPDw/8+OOPGDduHJo1a4YuXbqUep3Fixdj3rx5eOutt7B582Y899xz6NmzJ1q3bl3qOW+//TYWL14MX19fPPvss3jyySfxyy+/AADWr1+PBQsW4NNPP0X37t3x7bffYvHixWjatGmV7/XNN9/Eli1b8OWXXyIsLAyLFi3CgAEDcPnyZXh7e2PmzJk4f/48du7ciUaNGuHy5cvIzc0FAPznP//B999/j++++w6hoaFISEhAQkJCletCDFd1Xqi3aUG/+JQcO9eEiIiIyDG88sorGDZsmMWx119/XXr94osvYteuXdi0aVOZ4WrQoEF4/vnnAZgC29KlS3Ho0KEyw9WCBQvQq1cvAMD06dMxePBg5OXlQa1W4+OPP8akSZMwceJEAMCsWbOwZ88eZGVV7X+iZ2dnY+XKlYiJiUFkZCQAYNWqVdi7dy9Wr16NN954A/Hx8ejYsSM6d+4MwNQiZxYfH4+WLVvigQcegCAICAsLq1I9qBDDVR0X5uMKAIhPZbgiIiKimuWskOP8uwPs9tm2Yg4SZgaDAe+//z42btyI69evQ6vVQqvVwtXVtczrdOjQQXpt7n6YnJxc4XMCAwMBAMnJyQgNDcXFixelsGZ233334cCBAxW6r+L+/fdf6HQ6dO/eXTqmUChw33334cKFCwCA5557DsOHD8fvv/+Ohx56CEOHDkW3bt0AANHR0XjwwQcRHh6OgQMH4uGHH8ZDDz1UpbqQCcNVHRfmY2q5up6WC53BCIWcw+SIiIioZgiCYLOuefZUPDQtXrwYS5cuxbJly9C+fXu4urrilVdeQX5+fpnXKT4RhiAIMBqNFT5HEAQAsDjHfMysomPNrDGfa+2a5mORkZGIi4vDjz/+iH379qFfv36YMmUKPvroI3Tq1AmxsbHYuXMn9u3bh5EjR6J///7YvHlzlevU0PE39TrOz10FlZMMBqOIxLRce1eHiIiIyOH89NNPGDJkCJ544glERESgWbNmuHTpUq3XIzw8HCdOnLA4durUqSpfr0WLFlAqlfj555+lYzqdDqdOncJdd90lHfP19UV0dDS+/vprLFu2zGJiDg8PD4waNQqrVq3Cxo0bsWXLFqSmpla5Tg2d4/+viXpOEASEervgUnIW4lJypG6CRERERFQxLVq0wJYtW3D06FF4eXlhyZIluHHjhkUAqQ0vvvginnrqKXTu3BndunXDxo0b8eeff6JZs2blnlt81kEAaNOmDZ577jm88cYb8Pb2RmhoKBYtWoScnBxMmjQJgGlc1z333IO2bdtCq9Xihx9+kO576dKlCAwMxN133w2ZTIZNmzYhICAAnp6eNr3vhoThygGE+RSEK467IiIiIqq0mTNnIjY2FgMGDICLiwuefvppDB06FOnp6bVaj7Fjx+LKlSt4/fXXkZeXh5EjRyI6OrpEa5Y1jz/+eIljsbGxeP/992E0GjFu3DhkZmaic+fO2L17N7y8vAAASqUSM2bMwNWrV+Hs7IwePXrg22+/BQC4ubnhgw8+wKVLlyCXy3Hvvfdix44dkMnYua2qBLE6HT3rqYyMDGg0GqSnp8PDw8Pe1cG7/3cea36JxVM9muLtwW3sXR0iIiKqJ/Ly8hAbG4umTZtCrVbbuzoN0oMPPoiAgAB89dVX9q5Kg1bW34XKZAO2XDkA86QWcZyOnYiIiMhh5eTk4LPPPsOAAQMgl8uxYcMG7Nu3D3v37rV31chGGK4cQGhBuOJ07ERERESOSxAE7NixA/Pnz4dWq0V4eDi2bNmC/v3727tqZCN27VB55MgRREVFISgoCIIgYPv27eWes379ekRERMDFxQWBgYGYOHEiUlJSrJb99ttvIQgChg4datuK17Iw78JwxV6cRERERI7J2dkZ+/btQ2pqKrKzs/H777+XWOyYHJtdw1V2djYiIiKwYsWKCpX/+eefMX78eEyaNAnnzp3Dpk2bcPLkSUyePLlE2bi4OLz++uvo0aOHratd6xp7uUAmADn5BtzK0tq7OkREREREZIVduwVGRkYiMjKywuWPHz+OJk2a4KWXXgIANG3aFM888wwWLVpkUc5gMGDs2LGYO3cufvrpJ6Slpdmy2rVO6SRDoMYZ19NyEZ+SAz93DjglIiIiIqprHGqexW7duuHatWvYsWMHRFHEzZs3sXnzZgwePNii3LvvvgtfX19pfv/yaLVaZGRkWGx1DSe1ICIiIiKq2xwuXK1fvx6jRo2CUqmUFjn7+OOPpTK//PILVq9ejVWrVlX4ugsXLoRGo5G2kJCQmqh+tUjhipNaEBERERHVSQ4Vrs6fP4+XXnoJs2bNwm+//YZdu3YhNjYWzz77LAAgMzMTTzzxBFatWoVGjRpV+LozZsxAenq6tCUkJNTULVRZqLcrACCB4YqIiIiIqE5yqKnYFy5ciO7du+ONN94AAHTo0AGurq7o0aMH5s+fj5s3b+Lq1auIioqSzjEajQAAJycnXLx4Ec2bNy9xXZVKBZVKVTs3UUWF3QKz7VwTIiIiIiKyxqFarnJyciCTWVZZLpcDAERRROvWrXH27FmcPn1a2h555BH06dMHp0+frpPd/Soq1JtrXRERERE1NL1798Yrr7wi7Tdp0gTLli0r85yKLnFUHltdpyGxa7jKysqSQhAAxMbG4vTp04iPjwdg6q43fvx4qXxUVBS2bt2KlStX4sqVK/jll1/w0ksv4b777kNQUBDUajXatWtnsXl6esLd3R3t2rWDUqm0x23ahHkh4dtZ+cjS6u1cGyIiIiL7unHjBl588UU0a9YMKpUKISEhiIqKwv79++1dNQCm31tLWxz42LFjEAQBv//+e6Wve/LkSTz99NPVrZ6FOXPm4O677y5xPCkpqVIze1dFTEwMPD09a/QzapNduwWeOnUKffr0kfanTp0KAJgwYQJiYmKQlJQkBS0AiI6ORmZmJlasWIHXXnsNnp6e6Nu3Lz744INar3tt81Ar4OWiwJ0cHeJTctAmyMPeVSIiIiKyi6tXr6J79+7w9PTEokWL0KFDB+h0OuzevRtTpkzB33//bfU8nU4HhUJRK3WcNGkShg0bhri4OISFhVm8t2bNGtx9993o1KlTpa/r6+trqyqWKyAgoNY+q76wa8tV7969IYpiiS0mJgaAKckeOnTI4pwXX3wR586dQ05ODhITE/H1118jODi41M+IiYmpN82ZoT6mSS3iUznuioiIiGqAKAL52fbZRLHC1Xz++echCAJOnDiBxx57DK1atULbtm0xdepUHD9+XConCAI+++wzDBkyBK6urpg/fz4AYOXKlWjevDmUSiXCw8Px1VdfWVx/zpw5CA0NhUqlQlBQkLTGKgB8+umnaNmyJdRqNfz9/fHYY49ZrePDDz8MPz8/6fdas5ycHGzcuBGTJk1CSkoKRo8ejcaNG8PFxQXt27fHhg0byrz34t0CL126hJ49e0KtVqNNmzbYu3dviXOmTZuGVq1awcXFBc2aNcPMmTOh0+kAmH5Xnjt3Ls6cOQNBECAIglTn4t0Cz549i759+8LZ2Rk+Pj54+umnkZWVJb0fHR2NoUOH4qOPPkJgYCB8fHwwZcoU6bOqIj4+HkOGDIGbmxs8PDwwcuRI3Lx5U3r/zJkz6NOnD9zd3eHh4YF77rkHp06dAgDExcUhKioKXl5ecHV1Rdu2bbFjx44q16UiHGpCi4YuzNsFZxLSuNYVERER1QxdDvBekH0++61EQOlabrHU1FTs2rULCxYsgKtryfLFu5jNnj0bCxcuxNKlSyGXy7Ft2za8/PLLWLZsGfr3748ffvgBEydOROPGjdGnTx9s3rwZS5cuxbfffou2bdvixo0bOHPmDABTr6uXXnoJX331Fbp164bU1FT89NNPVuvp5OSE8ePHIyYmBrNmzYIgCACATZs2IT8/H2PHjkVOTg7uueceTJs2DR4eHvjxxx8xbtw4NGvWDF26dCn3uzAajRg2bBgaNWqE48ePIyMjw2J8lpm7uztiYmIQFBSEs2fP4qmnnoK7uzvefPNNjBo1Cn/99Rd27dqFffv2AQA0Gk2Ja+Tk5GDgwIG4//77cfLkSSQnJ2Py5Ml44YUXLALkwYMHERgYiIMHD+Ly5csYNWoU7r77bjz11FPl3k9xoihi6NChcHV1xeHDh6HX6/H8889j1KhRUgPM2LFj0bFjR6xcuRJyuRynT5+WWienTJmC/Px8HDlyBK6urjh//jzc3NwqXY/KYLhyIFzrioiIiBq6y5cvSxOZVcSYMWPw5JNPWuxHR0fj+eefBwCpteujjz5Cnz59EB8fj4CAAPTv3x8KhQKhoaG47777AJhaUVxdXfHwww/D3d0dYWFh6NixY6mf/eSTT+LDDz/EoUOHpKEwa9aswbBhw+Dl5QUvLy+8/vrrUvkXX3wRu3btwqZNmyoUrvbt24cLFy7g6tWraNy4MQDgvffeKzFO6p133pFeN2nSBK+99ho2btyIN998E87OznBzc4OTk1OZ3QDXr1+P3NxcrFu3Tgq1K1asQFRUFD744AP4+/sDALy8vLBixQrI5XK0bt0agwcPxv79+6sUrvbt24c///wTsbGx0sR0X331Fdq2bYuTJ0/i3nvvRXx8PN544w3peWjZsqV0fnx8PIYPH4727dsDAJo1a1bpOlQWw5UDkWYMZMsVERER1QSFi6kFyV6fXQFiQfdBc0tQeTp37myxf+HChRITQnTv3h3Lly8HAIwYMQLLli1Ds2bNMHDgQAwaNAhRUVFwcnLCgw8+iLCwMOm9gQMH4tFHH4WLiwvWr1+PZ555Rrrmzp070aNHD3Tr1g1r1qxBnz598O+//+Knn37Cnj17AAAGgwHvv/8+Nm7ciOvXr0Or1UKr1VptkbPmwoULCA0NlYIVAHTt2rVEuc2bN2PZsmW4fPkysrKyoNfr4eFRufH7Fy5cQEREhEXdunfvDqPRiIsXL0rhqm3bttJs3gAQGBiIs2fPVuqzin5mSEiIxYzfbdq0gaenJy5cuIB7770XU6dOxeTJk/HVV1+hf//+GDFihLT00ksvvYTnnnsOe/bsQf/+/TF8+HB06NChSnWpKIeair2hCysYcxXHMVdERERUEwTB1DXPHlsFw1LLli0hCAIuXLhQofLWgkrxYCaKonQsJCQEFy9exCeffAJnZ2c8//zz6NmzJ3Q6Hdzd3fH7779jw4YNCAwMxKxZsxAREYG0tDQ88sgjFssBmUPdpEmTsGXLFmRkZGDt2rUICwtDv379AACLFy/G0qVL8eabb+LAgQM4ffo0BgwYgPz8/Ardm2hlnFrxezt+/Dgef/xxREZG4ocffsAff/yBt99+u8KfYe07Kuszi08YIgiCtO5sZZX2mUWPz5kzB+fOncPgwYNx4MABtGnTBtu2bQMATJ48GVeuXMG4ceNw9uxZdO7cGR9//HGV6lJRDFcOxNwtMDEtDzpD1R5SIiIiIkfm7e2NAQMG4JNPPkF2dsn/4ZyWllbm+XfddRd+/vlni2NHjx7FXXfdJe07OzvjkUcewX/+8x8cOnQIx44dk1pfnJyc0L9/fyxatAh//vknrl69igMHDsDd3R0tWrSQNmdnZwDAyJEjIZfL8c033+DLL7/ExIkTpWDw008/YciQIXjiiScQERGBZs2a4dKlSxX+Ltq0aYP4+HgkJha2Nh47dsyizC+//IKwsDC8/fbb6Ny5M1q2bIm4uDiLMkqlEgaDodzPOn36tMV3/ssvv0Amk6FVq1YVrnNlmO8vISFBOnb+/Hmkp6db/Hm1atUKr776Kvbs2YNhw4Zh7dq10nshISF49tlnsXXrVrz22mtYtWpVjdTVjN0CHYifuwpqhQx5OiOu38lFk0YVazImIiIiqk8+/fRTdOvWDffddx/effdddOjQAXq9Hnv37sXKlSvLbNV64403MHLkSHTq1An9+vXD//3f/2Hr1q3SZA4xMTEwGAzo0qULXFxc8NVXX8HZ2RlhYWH44YcfcOXKFfTs2RNeXl7YsWMHjEYjwsPDS/08Nzc3jBo1Cm+99RbS09MRHR0tvdeiRQts2bIFR48ehZeXF5YsWYIbN25YBIey9O/fH+Hh4Rg/fjwWL16MjIwMvP322xZlWrRogfj4eHz77be499578eOPP0otO2ZNmjSR1ptt3Lgx3N3doVKpLMqMHTsWs2fPxoQJEzBnzhzcunULL774IsaNGyd1Cawqg8EgrXtrplQq0b9/f3To0AFjx47FsmXLpAktevXqhc6dOyM3NxdvvPEGHnvsMTRt2hTXrl3DyZMnMXz4cADAK6+8gsjISLRq1Qp37tzBgQMHKvzdVhVbrhyIIAjSuCtOakFEREQNVdOmTfH777+jT58+eO2119CuXTs8+OCD2L9/P1auXFnmuUOHDsXy5cvx4Ycfom3btvjvf/+LtWvXonfv3gBMsw2uWrUK3bt3R4cOHbB//3783//9H3x8fODp6YmtW7eib9++uOuuu/DZZ59hw4YNaNu2bZmfOWnSJNy5cwf9+/dHaGiodHzmzJno1KkTBgwYgN69eyMgIABDhw6t8Pcgk8mwbds2aLVa3HfffZg8eTIWLFhgUWbIkCF49dVX8cILL+Duu+/G0aNHMXPmTIsyw4cPx8CBA9GnTx/4+vpanQ7excUFu3fvRmpqKu6991489thj6NevH1asWFHh+pYmKysLHTt2tNgGDRokTQXv5eWFnj17on///mjWrBk2btwIAJDL5UhJScH48ePRqlUrjBw5EpGRkZg7dy4AU2ibMmUK7rrrLgwcOBDh4eH49NNPq13fsgiitc6aDVxGRgY0Gg3S09MrPdivpk3+8hT2XbiJeUPbYdz9YeWfQERERFSKvLw8xMbGomnTplCr1fauDpHdlPV3oTLZgC1XDsY87io+hZNaEBERERHVJQxXDkZa64rTsRMRERER1SkMVw4mxLzWFcdcERERERHVKQxXDiasSLjicDkiIiIiorqD4crBNPZygUwAcvINuJWltXd1iIiIqB7g/7Clhs5WfwcYrhyM0kmGQI1pUbp4jrsiIiKialAoFACAnBz+TkENW35+PgDT9O7VwUWEHVCYjwuup+UiLiUHnZt427s6RERE5KDkcjk8PT2RnJwMwLSWkSAIdq4VUe0yGo24desWXFxc4ORUvXjEcOWAwnxccPTfFC4kTERERNUWEBAAAFLAImqIZDIZQkNDq/0/FxiuHFCotysArnVFRERE1ScIAgIDA+Hn5wedTmfv6hDZhVKphExW/RFTDFcOSFrrii1XREREZCNyubza402IGjpOaOGAQs3TsXNCCyIiIiKiOoPhygGZW65SsvORpdXbuTZERERERAQwXDkkd7UC3q5KAEAcx10REREREdUJDFcOytw1MIHjroiIiIiI6gSGKwclTWrBcVdERERERHUCw5WDMrdcccZAIiIiIqK6geHKQXHGQCIiIiKiuoXhykGF+ZgWEo5L5YQWRERERER1AcOVgzKPuUpMy4POYLRzbYiIiIiIiOHKQfm5q6BWyGAwirh+J9fe1SEiIiIiavAYrhyUIAic1IKIiIiIqA5huHJgod6mcVfxXEiYiIiIiMjuGK4cGNe6IiIiIiKqOxiuHJgUrtgtkIiIiIjI7hiuHBjXuiIiIiIiqjvsGq6OHDmCqKgoBAUFQRAEbN++vdxz1q9fj4iICLi4uCAwMBATJ05ESkqK9P6qVavQo0cPeHl5wcvLC/3798eJEydq8C7sx7zWVXxqDkRRtHNtiIiIiIgaNruGq+zsbERERGDFihUVKv/zzz9j/PjxmDRpEs6dO4dNmzbh5MmTmDx5slTm0KFDGD16NA4ePIhjx44hNDQUDz30EK5fv15Tt2E3wZ7OkAlArs6AW1lae1eHiIiIiKhBc7Lnh0dGRiIyMrLC5Y8fP44mTZrgpZdeAgA0bdoUzzzzDBYtWiSVWb9+vcU5q1atwubNm7F//36MHz/e6nW1Wi202sJwkpGRUZnbsBulkwxBns64dicX8Sk58HNX27tKREREREQNlkONuerWrRuuXbuGHTt2QBRF3Lx5E5s3b8bgwYNLPScnJwc6nQ7e3t6lllm4cCE0Go20hYSE1ET1a4S01hXHXRERERER2ZXDhav169dj1KhRUCqVCAgIgKenJz7++ONSz5k+fTqCg4PRv3//UsvMmDED6enp0paQkFAT1a8RnDGQiIiIiKhucKhwdf78ebz00kuYNWsWfvvtN+zatQuxsbF49tlnrZZftGgRNmzYgK1bt0KtLr3LnEqlgoeHh8XmKLiQMBERERFR3WDXMVeVtXDhQnTv3h1vvPEGAKBDhw5wdXVFjx49MH/+fAQGBkplP/roI7z33nvYt28fOnToYK8q1zi2XBERERER1Q0O1XKVk5MDmcyyynK5HAAspiL/8MMPMW/ePOzatQudO3eu1TrWNq51RURERERUN9i15SorKwuXL1+W9mNjY3H69Gl4e3sjNDQUM2bMwPXr17Fu3ToAQFRUFJ566imsXLkSAwYMQFJSEl555RXcd999CAoKAmDqCjhz5kx88803aNKkCW7cuAEAcHNzg5ubW+3fZA0zt1ylZOcjS6uHm8qhGiOJiIiIiOoNu7ZcnTp1Ch07dkTHjh0BAFOnTkXHjh0xa9YsAEBSUhLi4+Ol8tHR0ViyZAlWrFiBdu3aYcSIEQgPD8fWrVulMp9++iny8/Px2GOPITAwUNo++uij2r25WuKuVsDbVQkAiOO4KyIiIiIiuxHEov3pCIBpnSuNRoP09HSHmNxi6Ce/4HRCGlaO7YTI9oHln0BERERERBVSmWzgUGOuyDpOakFEREREZH8MV/VAGBcSJiIiIiKyO4areiDUp2Ctq1SOuSIiIiIisheGq3pA6hbIlisiIiIiIrthuKoHzN0CE9NyoTMY7VwbIiIiIqKGieGqHvB1V0GtkMEoAtfv5Nq7OkREREREDRLDVT0gCAJCvTljIBERERGRPTFc1ROh3gWTWnAhYSIiIiIiu2C4qic4qQURERERkX0xXNUTXEiYiIiIiMi+GK7qCfOYq3i2XBERERER2QXDVT0RJi0knANRFO1cGyIiIiKihofhqp4I9nSGTABydQbcytTauzpERERERA0Ow1U9oXSSIcjTGQDHXRERERER2QPDVT3CGQOJiIiIiOyH4aoe4VpXRERERET2w3BVj3A6diIiIiIi+2G4qkfCzNOxM1wREREREdU6hqt6JIRrXRERERER2Q3DVT1i7haYkp2PLK3ezrUhIiIiImpYGK7qEXe1At6uSgBAHCe1ICIiIiKqVQxX9UwouwYSEREREdkFw1U9wxkDiYiIiIjsg+GqnjHPGMiFhImIiIiIahfDVT0T6lOwkHAqx1wREREREdUmhqt6RuoWyJYrIiIiIqJaxXBVz5i7BSam5SJfb7RzbYiIiIiIGg6Gq3rG110FZ4UcRhG4npZr7+oQERERETUYDFf1jCAI0nTsXOuKiIiIiKj2MFzVQ6EF467iOR07EREREVGtYbiqhzgdOxERERFR7WO4qofC2HJFRERERFTr7Bqujhw5gqioKAQFBUEQBGzfvr3cc9avX4+IiAi4uLggMDAQEydOREpKikWZLVu2oE2bNlCpVGjTpg22bdtWQ3dQN4UUtFzFs+WKiIiIiKjW2DVcZWdnIyIiAitWrKhQ+Z9//hnjx4/HpEmTcO7cOWzatAknT57E5MmTpTLHjh3DqFGjMG7cOJw5cwbjxo3DyJEj8euvv9bUbdQ5YdJCwjkQRdHOtSEiIiIiahgEsY789i0IArZt24ahQ4eWWuajjz7CypUr8e+//0rHPv74YyxatAgJCQkAgFGjRiEjIwM7d+6UygwcOBBeXl7YsGFDheqSkZEBjUaD9PR0eHh4VO2G7Chfb0TrmTthFIETb/WDn4fa3lUiIiIiInJIlckGDjXmqlu3brh27Rp27NgBURRx8+ZNbN68GYMHD5bKHDt2DA899JDFeQMGDMDRo0dLva5Wq0VGRobF5siUTjIEeToDAOI47oqIiIiIqFY4XLhav349Ro0aBaVSiYCAAHh6euLjjz+Wyty4cQP+/v4W5/n7++PGjRulXnfhwoXQaDTSFhISUmP3UFvMk1pwxkAiIiIiotrhUOHq/PnzeOmllzBr1iz89ttv2LVrF2JjY/Hss89alBMEwWJfFMUSx4qaMWMG0tPTpc3cxdCRhXoXjLviQsJERERERLXCyd4VqIyFCxeie/fueOONNwAAHTp0gKurK3r06IH58+cjMDAQAQEBJVqpkpOTS7RmFaVSqaBSqWq07rVNarlit0AiIiIiolrhUC1XOTk5kMksqyyXywFAmhWva9eu2Lt3r0WZPXv2oFu3brVTyTqCCwkTEREREdUuu7ZcZWVl4fLly9J+bGwsTp8+DW9vb4SGhmLGjBm4fv061q1bBwCIiorCU089hZUrV2LAgAFISkrCK6+8gvvuuw9BQUEAgJdffhk9e/bEBx98gCFDhuB///sf9u3bh59//tku92gvoVxImIiIiIioVtm15erUqVPo2LEjOnbsCACYOnUqOnbsiFmzZgEAkpKSEB8fL5WPjo7GkiVLsGLFCrRr1w4jRoxAeHg4tm7dKpXp1q0bvv32W6xduxYdOnRATEwMNm7ciC5dutTuzdmZea2r1Ox8ZObp7FwbIiIiIqL6r86sc1WXOPo6V2b3zNuLlOx8/PDiA2gXrLF3dYiIiIiIHE69XeeKKoddA4mIiIiIag/DVT1mntSC4YqIiIiIqOYxXNVjoZwxkIiIiIio1jBc1WOhBZNaxKdyIWEiIiIioprGcFWPSQsJs+WKiIiIiKjGMVzVY+YxV4lpucjXG+1cGyIiIiKi+o3hqh7zdVfBWSGHUQSup+XauzpERERERPUaw1U9JghCkUktOO6KiIiIiKgmMVzVc1zrioiIiIiodjBc1XNhnI6diIiIiKhWMFzVc5wxkIiIiIiodjBc1XNc64qIiIiIqHYwXNVz5m6B8ak5EEXRzrUhIiIiIqq/GK7quWAvZ8hlAvJ0RiRnau1dHSIiIiKieovhqp5TyGUI8lQD4LgrIiIiIqKaxHDVAIR6czp2IiIiIqKaxnDVAIR6F0xqwYWEiYiIiIhqDMNVAyBNx86WKyIiIiKiGsNw1QBwIWEiIiIioprHcNUAhPpwzBURERERUU1juGoAwgoWEk7Nzkdmns7OtSEiIiIiqp8YrhoAN5UTfFyVANg1kIiIiIiopjBcNRDsGkhEREREVLMYrhoITmpBRERERFSzGK4aiNCCcVfxqVzrioiIiIioJjBcNRBsuSIiIiIiqlkMVw2EtJAwwxURERERUY1guGogzBNaJKXnIl9vtHNtiIiIiIjqH4arBsLXTQVnhRxGEbielmvv6hARERER1TsMVw2EIAgIlcZdcVILIiIiIiJbY7hqQLjWFRERERFRzWG4akA4YyARERERUc1huGpAOGMgEREREVHNsWu4OnLkCKKiohAUFARBELB9+/Yyy0dHR0MQhBJb27ZtLcotW7YM4eHhcHZ2RkhICF599VXk5eXV4J04Bi4kTERERERUc+warrKzsxEREYEVK1ZUqPzy5cuRlJQkbQkJCfD29saIESOkMuvXr8f06dMxe/ZsXLhwAatXr8bGjRsxY8aMmroNh2HuFhifmgNRFO1cGyIiIiKi+sXJnh8eGRmJyMjICpfXaDTQaDTS/vbt23Hnzh1MnDhROnbs2DF0794dY8aMAQA0adIEo0ePxokTJ2xXcQcV7OUMuUxAns6I5Ewt/D3U9q4SEREREVG94dBjrlavXo3+/fsjLCxMOvbAAw/gt99+k8LUlStXsGPHDgwePLjU62i1WmRkZFhs9ZFCLkOQpylQcdwVEREREZFt2bXlqjqSkpKwc+dOfPPNNxbHH3/8cdy6dQsPPPAARFGEXq/Hc889h+nTp5d6rYULF2Lu3Lk1XeU6IczbFQmpuYhLycZ9Tb3tXR0iIiIionrDYVuuYmJi4OnpiaFDh1ocP3ToEBYsWIBPP/0Uv//+O7Zu3YoffvgB8+bNK/VaM2bMQHp6urQlJCTUcO3th2tdERERERHVDIdsuRJFEWvWrMG4ceOgVCot3ps5cybGjRuHyZMnAwDat2+P7OxsPP3003j77bchk5XMkyqVCiqVqlbqbm9c64qIiIiIqGY4ZMvV4cOHcfnyZUyaNKnEezk5OSUClFwuhyiKnCEPRda6YssVEREREZFN2bXlKisrC5cvX5b2Y2Njcfr0aXh7eyM0NBQzZszA9evXsW7dOovzVq9ejS5duqBdu3YlrhkVFYUlS5agY8eO6NKlCy5fvoyZM2fikUcegVwur/F7qutCzNOxp3CtKyIiIiIiW7JruDp16hT69Okj7U+dOhUAMGHCBMTExCApKQnx8fEW56Snp2PLli1Yvny51Wu+8847EAQB77zzDq5fvw5fX19ERUVhwYIFNXcjDiSsYCHhOzk6ZOTp4KFW2LlGRERERET1gyCyr1wJGRkZ0Gg0SE9Ph4eHh72rY3P3zNuLlOx8/PDiA2gXrCn/BCIiIiKiBqoy2cAhx1xR9XDGQCIiIiIi22O4aoA4YyARERERke0xXDVAoQXjruJTOakFEREREZGtMFw1QGy5IiIiIiKyPYarBkha64rhioiIiIjIZhiuGiDzhBZJ6bnI1xvtXBsiIiIiovqB4aoB8nVTwUUph1EErt1h6xURERERkS0wXDVAgiAg1DzuitOxExERERHZBMNVA2UOV/Ecd0VEREREZBMMVw0UJ7UgIiIiIrIthqsGSmq54lpXREREREQ2wXDVQBUuJMyWKyIiIiIiW6hSuEpISMC1a9ek/RMnTuCVV17B559/brOKUc0Kk1quciCKop1rQ0RERETk+KoUrsaMGYODBw8CAG7cuIEHH3wQJ06cwFtvvYV3333XphWkmhHs5Qy5TECezojkTK29q0NERERE5PCqFK7++usv3HfffQCA7777Du3atcPRo0fxzTffICYmxpb1oxqikMsQ5KkGwEktiIiIiIhsoUrhSqfTQaVSAQD27duHRx55BADQunVrJCUl2a52VKPCvE3jruJSOKkFEREREVF1VSlctW3bFp999hl++ukn7N27FwMHDgQAJCYmwsfHx6YVpJoT6lM47oqIiIiIiKqnSuHqgw8+wH//+1/07t0bo0ePRkREBADg+++/l7oLUt1nntSC3QKJiIiIiKrPqSon9e7dG7dv30ZGRga8vLyk408//TRcXFxsVjmqWdJCwmy5IiIiIiKqtiq1XOXm5kKr1UrBKi4uDsuWLcPFixfh5+dn0wpSzQktGHMVzzFXRERERETVVqVwNWTIEKxbtw4AkJaWhi5dumDx4sUYOnQoVq5cadMKUs0xj7m6k6NDRp7OzrUhIiIiInJsVQpXv//+O3r06AEA2Lx5M/z9/REXF4d169bhP//5j00rSDXHTeWERm5KAEA8x10REREREVVLlcJVTk4O3N3dAQB79uzBsGHDIJPJcP/99yMuLs6mFaSaFcpJLYiIiIiIbKJK4apFixbYvn07EhISsHv3bjz00EMAgOTkZHh4eNi0glSzpHCVynFXRERERETVUaVwNWvWLLz++uto0qQJ7rvvPnTt2hWAqRWrY8eONq0g1axQH/OkFmy5IiIiIiKqjipNxf7YY4/hgQceQFJSkrTGFQD069cPjz76qM0qRzXPvNYVFxImIiIiIqqeKoUrAAgICEBAQACuXbsGQRAQHBzMBYQdkLTWFVuuiIiIiIiqpUrdAo1GI959911oNBqEhYUhNDQUnp6emDdvHoxGo63rSDXIPB17Unou8vX8syMiIiIiqqoqtVy9/fbbWL16Nd5//310794doijil19+wZw5c5CXl4cFCxbYup5UQ3zdVHBRypGTb8C1Ozlo5utm7yoRERERETmkKoWrL7/8El988QUeeeQR6VhERASCg4Px/PPPM1w5EEEQEOrtgr9vZCIuleGKiIiIiKiqqtQtMDU1Fa1bty5xvHXr1khNTa12pah2madj54yBRERERERVV6VwFRERgRUrVpQ4vmLFCnTo0KHalaLaxUktiIiIiIiqr0rdAhctWoTBgwdj37596Nq1KwRBwNGjR5GQkIAdO3bYuo5Uw6S1rriQMBERERFRlVWp5apXr174559/8OijjyItLQ2pqakYNmwYzp07h7Vr11b4OkeOHEFUVBSCgoIgCAK2b99eZvno6GgIglBia9u2rUW5tLQ0TJkyBYGBgVCr1bjrrrsY+spgXuuKLVdERERERFVX5XWugoKCSkxccebMGXz55ZdYs2ZNha6RnZ2NiIgITJw4EcOHDy+3/PLly/H+++9L+3q9HhERERgxYoR0LD8/Hw8++CD8/PywefNmNG7cGAkJCXB3d6/gnTU85m6B8ak5MBpFyGSCnWtEREREROR4qhyubCEyMhKRkZEVLq/RaKDRaKT97du3486dO5g4caJ0bM2aNUhNTcXRo0ehUCgAAGFhYbardD0U5OkMuUyAVm9EcqYWARq1vatERERERORwqtQtsK5YvXo1+vfvbxGevv/+e3Tt2hVTpkyBv78/2rVrh/feew8Gg6HU62i1WmRkZFhsDYlCLkOQpylQxaVw3BURERERUVU4bLhKSkrCzp07MXnyZIvjV65cwebNm2EwGLBjxw688847WLx4cZlrby1cuFBqFdNoNAgJCanp6tc5Yd6mSS3iUjnuioiIiIioKirVLXDYsGFlvp+WlladulRKTEwMPD09MXToUIvjRqMRfn5++PzzzyGXy3HPPfcgMTERH374IWbNmmX1WjNmzMDUqVOl/YyMjAYXsEJ9XIDLQALDFRERERFRlVQqXBUd71Ta++PHj69WhSpCFEWsWbMG48aNg1KptHgvMDAQCoUCcrlcOnbXXXfhxo0byM/PL1EeAFQqFVQqVY3Xuy7jjIFERERERNVTqXBVmWnWa9Lhw4dx+fJlTJo0qcR73bt3xzfffAOj0QiZzNTr8Z9//kFgYKDVYEUm0kLCbLkiIiIiIqoSu465ysrKwunTp3H69GkAQGxsLE6fPo34+HgApu561lrCVq9ejS5duqBdu3Yl3nvuueeQkpKCl19+Gf/88w9+/PFHvPfee5gyZUqN3oujCy0YcxXPCS2IiIiIiKrErlOxnzp1Cn369JH2zeOeJkyYgJiYGCQlJUlByyw9PR1btmzB8uXLrV4zJCQEe/bswauvvooOHTogODgYL7/8MqZNm1ZzN1IPhBa0XN3J0SEjTwcPtcLONSIiIiIiciyCKIqivStR12RkZECj0SA9PR0eHh72rk6t6Tx/L25n5eOHFx9Au+Cyx9cRERERETUElckGDjsVO9leKCe1ICIiIiKqMoYrkoT5mNe64rgrIiIiIqLKYrgiibnlKp4tV0RERERElcZwRRJpOnaGKyIiIiKiSmO4Iok5XMVzrSsiIiIiokpjuCKJea2rxPRcaPUGO9eGiIiIiMixMFyRpJGbEi5KOUQRuHYn197VISIiIiJyKAxXJBEEgZNaEBERERFVEcMVWZDCFcddERERERFVCsMVWeCMgUREREREVcNwRRZCCxYSjudCwkRERERElcJwRRbCvNlyRURERERUFQxXZKHoWldGo2jn2hAREREROQ6GK7IQ5OkMuUyAVm9EcqbW3tUhIiIiInIYDFdkQSGXIdjTGQAQl8JxV0REREREFcVwRSVIMwZyOnYiIiIiogpjuKISuJAwEREREVHlMVxRCWy5IiIiIiKqPIYrKiHUu2CtK465IiIiIiKqMIYrKsHcLZAtV0REREREFcdwRSWEFnQLTMvRIT1XZ+faEBERERE5BoYrKsFN5YRGbkoAQAJbr4iIiIiIKoThiqySugZyxkAiIiIiogphuCKrwnxMk1rEpXJSCyIiIiKiimC4Iqu41hURERERUeUwXJFV0lpXDFdERERERBXCcEVWmcNVPCe0ICIiIiKqEIYrssq8kHBiei60eoOda0NEREREVPcxXJFVjdyUcFHKIYrAtTu59q4OEREREVGdx3BFVgmCwEktiIiIiIgqgeGKSlU4qQWnYyciIiIiKg/DFZWqcK0rtlwREREREZWH4YpKFcJugUREREREFWbXcHXkyBFERUUhKCgIgiBg+/btZZaPjo6GIAgltrZt21ot/+2330IQBAwdOtT2lW8AwgrCFVuuiIiIiIjKZ9dwlZ2djYiICKxYsaJC5ZcvX46kpCRpS0hIgLe3N0aMGFGibFxcHF5//XX06NHD1tVuMIqudWU0inauDRERERFR3eZkzw+PjIxEZGRkhctrNBpoNBppf/v27bhz5w4mTpxoUc5gMGDs2LGYO3cufvrpJ6Slpdmqyg1KkKcz5DIB+XojkjO1CNCo7V0lIiIiIqI6y6HHXK1evRr9+/dHWFiYxfF3330Xvr6+mDRpUoWuo9VqkZGRYbERoJDLEOzpDIAzBhIRERERlcdhw1VSUhJ27tyJyZMnWxz/5ZdfsHr1aqxatarC11q4cKHUKqbRaBASEmLr6josaTp2jrsiIiIiIiqTw4armJgYeHp6WkxWkZmZiSeeeAKrVq1Co0aNKnytGTNmID09XdoSEhJqoMaOiQsJExERERFVjF3HXFWVKIpYs2YNxo0bB6VSKR3/999/cfXqVURFRUnHjEYjAMDJyQkXL15E8+bNS1xPpVJBpVLVfMUdEFuuiIiIiIgqxiHD1eHDh3H58uUSY6pat26Ns2fPWhx75513kJmZieXLl7O7XxWEepsWEo7nmCsiIiIiojLZNVxlZWXh8uXL0n5sbCxOnz4Nb29vhIaGYsaMGbh+/TrWrVtncd7q1avRpUsXtGvXzuK4Wq0ucczT0xMAShynimHLFRERERFRxdh1zNWpU6fQsWNHdOzYEQAwdepUdOzYEbNmzQJgmrQiPj7e4pz09HRs2bKlwjMBUvWYx1yl5eiQnquzc22IiIiIiOouQRRFrg5bTEZGBjQaDdLT0+Hh4WHv6thd5/n7cDtLi/974QG0b6wp/wQiIiIionqiMtnAYWcLpNpT2DWQ466IiIiIiErDcEXlMncNjON07EREREREpWK4onJxrSsiIiIiovIxXFG52C2QiIiIiKh8DFeO4NY/dv14c7hKSM21az2IiIiIiOoyhqu67o+vgU+7AD8vA+w0saN5IeHE9Fxo9Qa71IGIiIiIqK5juKrrks4AohHYNxvYMgnIr/1xT43clHBRyiGKwLU7bL0iIiIiIrKG4aqui1wEDF4MyJyAv7YAax4C7sTVahUEQeCkFkRERERE5WC4qusEAbh3MjD+e8ClEXDjLLCqDxD7U61WQ5rUIoWTWhARERERWcNw5SiadAeeOQwERgA5KcC6IcCv/621cVhhPqZxV3GpbLkiIiIiIrKG4cqRaBoDT+4G2o8ERAOw803gf1MAXV6NfzS7BRIRERERlY3hytEonIFhnwMPLQAEGXB6PRAzCMhIrNGPLVzriuGKiIiIiMgahitHJAhAtxeAJ7YCak/g+m/A572B+F9r7CPDCqZjj0/NgdFonynhiYiIiIjqMoYrR9a8D/D0IcCvDZB1E4gZDPz2ZY18VJCnGnKZgHy9ETcza74bIhERERGRo2G4cnTeTYFJe4G7HgGMOuD/XgJ+fA3Q59v0Y5zkMgR7OgMA4jjuioiIiIioBIar+kDlBoxcB/R9B4AAnPzCNJtgVrJNP8Y87oqTWhARERERlcRwVV8IAtDzDWD0t4DKA4g/ahqHlfiHzT7CPGNgXCrXuiIiIiIiKo7hqr4JHwhM3g/4tAQyrgNrBgJ/fmeTSxcuJMyWKyIiIiKi4hiu6iPfVsBT+4GWAwB9HrD1KWD324BBX63LhhbMGJjA6diJiIiIiEpguKqv1Bpg9Aagx+um/WMrgPXDgZzUKl+Sa10REREREZWO4ao+k8mBfjOBEV8CClfgyiHTOKyb56p0OfOYq7QcHdJzdbarJxERERFRPcBw1RC0HQpM3gt4hgFpccAXDwLn/1fpy7iqnNDITQWAMwYSERERERXHcNVQ+Lc1LTjctBegywa+Gw/snwcYjZW6TGHXQM4YSERERERUFMNVQ+LiDTyxFej6gmn/p4+ADY8DeekVvkSYN2cMJCIiIiKyhuGqoZE7AQMWAI/+F5CrgEu7gVX9gNuXKnR6KBcSJiIiIiKyiuGqoYp4HHhyF+ARDKRcAlb1BS7uKvc0dgskIiIiIrKO4aohC+5kGocV2hXQZpi6CB75EBDFUk8xr3XFlisiIiIiIksMVw2dmx8w/nug8yQAInBgPrBpAqDNslrcPB17UkYetHpDLVaUiIiIiKhuY7giwEkJPLwEiFoOyBSmadpXPwSkxpYo2shNCRelHKIIJKTm2qGyRERERER1E8MVFbonGoj+AXD1A5LPmRYc/vegRRFBEKTWq3iOuyIiIiIikjBckaXQ+4FnDgPB9wB5acDXw4CjKyzGYUmTWnDcFRERERGRhOGKSvIIAqJ3AHePBUQjsOdtYNszgM7UDTDMxzSpxQ9/JiH2NluviIiIiIgAhisqjUINDPkEGPgBIMiBPzcCawYAaQno1twHggD8FncH/ZccxoytZ3EjPc/eNSYiIiIisiu7hqsjR44gKioKQUFBEAQB27dvL7N8dHQ0BEEosbVt21Yqs2rVKvTo0QNeXl7w8vJC//79ceLEiRq+k3pKEID7nwXGbwecvYGkM8DnvdFbfRk/vtgDfVv7wWAUseFEPHp9eBDv7biAO9n59q41EREREZFd2DVcZWdnIyIiAitWrKhQ+eXLlyMpKUnaEhIS4O3tjREjRkhlDh06hNGjR+PgwYM4duwYQkND8dBDD+H69es1dRv1X9OepvWw/NsDObeBL6PQ5vp3WDOhMzY92xX3NvGCVm/E50euoOeig/h4/yVka/X2rjURERERUa0SRLGMFWNrkSAI2LZtG4YOHVrhc7Zv345hw4YhNjYWYWFhVssYDAZ4eXlhxYoVGD9+fIWum5GRAY1Gg/T0dHh4eFS4PvVefg7wvynAua2mfTd/wK8NRL82+NsYgk8vqLHnlie0UKKRmxIv9GmB0V1CoXKS27feRERERERVVJls4FRLdaoRq1evRv/+/UsNVgCQk5MDnU4Hb2/vUstotVpotVppPyMjw6b1rDeULsBja4DADsDB94Csm0DWTQhXDuIuAB8DENUyJAgB+EvbGBd3hGDuoebo+UBvPNi9C+RODv24ERERERGVyWF/201KSsLOnTvxzTfflFlu+vTpCA4ORv/+/Usts3DhQsydO9fWVayfBAF44FXg3slA8t+m9bBungeSzwM3z0HITUWomIhQeSIGyU8AOgAHFyHvoBJZXq3gERYBwb8t4NcG8G8LuPnZ+46IiIiIiGzCYcNVTEwMPD09y+xGuGjRImzYsAGHDh2CWq0utdyMGTMwdepUaT8jIwMhISG2rG79o3IHQu41bWaiaGrNunkOSD4PfdI53In9A+5Z/0KNfKjv/AXc+cvyOi6NAP82gF/bwp9+rQGla+3eDxERERFRNTlkuBJFEWvWrMG4ceOgVCqtlvnoo4/w3nvvYd++fejQoUOZ11OpVFCpVDVR1YZFEAD3ANPWoh+cAPgCSM/Ow9d7D+Psb8fQTIxDuJCAu1XX4a9PgpBzG4g9YtoKLwR4NTG1bPm1KQxd3s0AuUM+skRERETUADjkb6qHDx/G5cuXMWnSJKvvf/jhh5g/fz52796Nzp0713LtqDiNqxqThw5Acr9e+OTAZbx4Ih66LBHOyMOEFnmY2DIX/rn/Si1eyL4F3Ik1bX//UHghuQrwDS8ZutwDTMGOiIiIiMiO7DpbYFZWFi5fvgwA6NixI5YsWYI+ffrA29sboaGhmDFjBq5fv45169ZZnDdu3DhcunQJx48fL3HNRYsWYebMmfjmm2/QvXt36bibmxvc3NwqVC/OFlizElJzsHTvP9h2+jpEEZAJwGP3NMbL/Vsh2NMZyLpVZCxXwc9bfwO6HOsXdPYq7FYY3BkI6wp4htbuTRERERFRvVSZbGDXcHXo0CH06dOnxPEJEyYgJiYG0dHRuHr1Kg4dOiS9l56ejsDAQCxfvhxPPfVUiXObNGmCuLi4Esdnz56NOXPmVKheDFe14+KNTHy05yL2nr8JAFDKZRjXNQzP924OH7di3TSNRlNLVvJ5y9CV+i8gGkte3KOxKWSFdgXCuptavNi6RURERESV5DDhqq5iuKpdv8XdwaJdf+PX2FQAgKtSjsk9mmFyj6ZwVyvKPlmXC9y6aApdN84C8ceBpDOAaLAs5+xdELS6AqHdTNPJy8u5NhERERE1eAxX1cRwVftEUcSRS7fx4e6/8dd10zpj3q5KPN+7OZ64PwxqRSUWItZmAddOAvHHgLijwLVTgD7XsozCBWh8LxDWzRS6Gt9rWseLiIiIiKgIhqtqYriyH6NRxM6/bmDxnou4cjsbABCkUePl/i0xvFNjOMlllb+oPt/UmhV/FIg7ZgpdeWmWZWROQFDHgtatbkBIF8Cl9IWniYiIiKhhYLiqJoYr+9MbjNj82zUs338JSel5AIBmvq54/aFwRLYLgFCd8VNGI3DrgqlVK/6YKXBlJpYs59emMGyFdgU0wVX/TCIiIiJySAxX1cRwVXfk6Qz4+ngcPjl4GXdydACADo01eGNAOB5o0ah6IctMFIG0uIJWrYLWrZRLJct5hprGa4UVTJLh04KTZBARERHVcwxX1cRwVfdk5umw6qdYrP7pCrLzTZNVdG3mgzcHhqNjqJftPzDrlqlVyzxu68afJWcldPUFQu8vDFz+7bnIMREREVE9w3BVTQxXddftLC0+OXgZ64/HI99gCjsPtfHH6wPC0crfveY+OC8DuHaicMzWtVOAQWtZRukGhNxXGLaC7wEUzjVXJyIiIiKqcQxX1cRwVfddu5OD5fsuYcvv12AUTb3zHu0YjOhuTdAuSAOZrIa76+m1QOIfheO24n8FtOmWZeRK0yQZ/u0ArzDAq0nhptbUbP2IiIiIyCYYrqqJ4cpxXE7OxEe7/8GuczekY77uKvRu5Yu+rf3wQMtG5a+VZQtGg2mtraLjtrJulF7e2csybJk3zzBA05hrcBERERHVEQxX1cRw5XjOJKThv0f+xeGLt6QxWQCgkAu4t4k3+rb2Q+9wPzT3dbXNJBjlEUUg9QqQcAJIuQzcuWqaNOPOVSD7VtnnCnJTwLIWvryamIIZJ9IgIiIiqhUMV9XEcOW48vVGnLyaigN/J+Pg38nSWllmod4u6NvaD31a+6FLU+/KLU5sK9qswqBVYosrOZarOJUG8Aq1EryaApoQwElZo9UnIiIiakgYrqqJ4ar+uHo72xS0Libj1yup0iQYAOCskKN7i0YFYcsXgZo6MPmE0WjqTlg0bBUNX2V1NQQACEVavcIAzyaWAcy1EVu9iIiIiCqB4aqaGK7qp2ytHj9fvo2DBWHrZoZlC9FdgR7o29o0VuvuEC/Ia3pSjKrIzwHS4ktp9boK6HPLPl/hagpZbr6Ayt3UCqZyB9QeBfseRfY9LPcVroBMVsM3SERERFS3MFxVE8NV/SeKIs4lZuDg38k4cDEZpxPSUPRvgpeLAr1a+aJPaz/0auULTxcH6GonikBWculdDjMSAVTnr7tQLHwVD2PFw1opQU2htsHNEhEREdUOhqtqYrhqeFKytDj8zy0c+DsZR/65hYw8vfSeTADuCfNCn9Z+6BPuh9YB7rUzKYat6fKA9ART0MpJBbQZBVumaR0vbWax/YItLwMQDeVevsLkymLBrCCQOXubui26+ZkWaHZtBLgWvHbx4QLNREREZBcMV9XEcNWw6Q1G/B6fJk2KcfFmpsX7QRo1erf2Q99wP3Rv0QjOSjtMilGbRBHQ5RYJXxllh7HSwlp+ZvmfVSoBcPEuCF1FNrei+36F4UzparPbJyIiooaN4aqaGK6oqGt3cnDw4i0c/DsZv1y+Da2+cFIMpZMMXZv5oG9rP/Rt7YcQbxc71rSOMxpNAatE+CoIazkpQPZt01T12clFXt9GpbszKlwsW77cfEsGM1dfUxBz9gJk9TwgExERUZUxXFUTwxWVJk9nwLF/U3Dg72Qc+DsZ19MsJ5Bo4edmmn0w3A+dm3hBIecEENVmNJi6MWYnF4atLPPrYlvWrfIn9ShOkAEujQq7IhbtlqhwBYx6U7dIo94UEC32DaZNLPgpvVd8v/i55veMRa5T2rnFPlPlDvi1MW3+bQC/toBPcy48TUREVEMYrqqJ4YoqQhRFXErOkoLWb3F3YDAW/nVyVzuhZ0tf3N/MGx0ae6J1oDtUTmwhqVGiCORnW7Z8ZSVbbxHLSgZyU+1dY9uQK4FGrSwDl38bwCOYU+8TERFVE8NVNTFcUVWk5+hw5JKp++Chf24hNTvf4n2lXIbWge6IaOyJDo01iAjxRHNft7o55XtDYdAXdEdMLmz5KtoSpssFZE4Fm8z0U5AX7MtNW9F9QV543KJsWecWLVveuXJTOEw+D9w8ByRfMG2ljWdTawpbufzuAvzbml47e9bq10xEROTIGK6qieGKqstgFPHntTQcungLpxPScOZaGtJydCXKuSrlaBdsClodGmsQ0dgTjb2cHXM2QrIPUTStfSYFrvPAzfNAyiVTN0JrPIJLtnI1agU4qWq37kRERA6A4aqaGK7I1kRRREJqLs5cS8Of19Jw5lo6/rqejpz8klOce7sq0aGxBh0aeyKi4KevO3/ppUrS5wO3/ylo3TpnClzJ503T8VsjyAGfFpaBy68N4BnGxaOLM8+gmZcG5KWbtlzz6zTr+3lppj8Td3/AozHgEVSwBRf+dPFmN04iojqI4aqaGK6oNhiMIi4nZ0mB689r6biQlAGdoeRfySCNuqB1yxS42jXWwEPNCQyoCvLSTYGraCtX8jnTcWsUrqYuhUW7Ffq3NU344cgM+pLhp8yQVOyYsWRLdLXJVcUCVxCgKRbEXBox7BIR1TKGq2piuCJ70eoNuJCUaWrdSkjHn9fScPlWFqz9LW3u6yqN3+oQ4ok2gR5QKzhhBlWBKAKZSYVBy/zz1j+AQWv9HFe/wlYuz1BTi4vFg1rktXTc2rEix6t0finXNOishyLzfn6W9fuqDEFuGr+m1gDqgp/SvpVjMgWQdRNIvwZkJBZs100/s5Mr9pkyBeARaBnAirZ+eQSbZrzk8gL1hyianpPb/wC3LxX8/AdIvWqaPdQjEHA3PxMFP90DTc+EsxdbQ4lsgOGqmhiuqC7J0upx9lq61Lp15loart0pOd24k0xA60B3i+6ELf3c4MTp4KmqDHog9d8ik2cUjOu6cxWVXnusrlK6F4ahUoNS8f2CY0pX2/3iqs83BVwpcF23DF8ZiUDmDVToexfkhb9cF28JM792D+D0/XWNLs/09614iLp9GdBlV+2aTupiwSsIcA+yDGFu/oDcybb3QlTPMFxVE8MV1XUpWVopaP1ZELxuZ+WXKOeskKNdsAc6NC6cMCPMx4UTZlD15GcDyX8XtnJl3QBQ8ExZPFtFXkvHrR0rcrxS55dRTuZUGIqsBiUvQOXhWL9UGnSmlq/ioatoS1hmkmlNtPIIMtMv1e4BgIsP4Oxt+unibfpuXLwLjnkXvqfkIunVJoqmGUql4FQkRN2JQ6nhWeYEeDcHGrU0TT7TqBXg3dTUApuRVBDMr5teZyQCmYmmz6kI6VkoGsithDD++VMDxnBVTQxX5GhEUURieh7OFMxM+GdCOs5eT0eWtuRscRpnBTo01qBtkAbtgzVoF+yBUG8GLqJ6wWgwreFmEcCKt4QlVW3MmJO6SODysgxeJcJYQRm1Z8McI2bQm1p4b/9jmrmzaJDKvVP6eWoN0Ci8IEAVCVJeYZVvadTlmUKX1CKaWBi8zCEs60bps4qWqJtnkeAVWCyEBbEbItVrDFfVxHBF9YHRKOLK7WycSSicofB8Ugby9cYSZT3UTmgXrCncgjzQxMcVMq7BRVT/GI1Azu3CoJWbCuSklvxZ9HVVJ/AQZKZfuK0Fr7JCmVzpGL+k56Wbuu1JLVEFISr1ShnfmWAap2gOTkVDlGuj2r1vo8G0pp+51bNECCsIYhXtluikNo3HdG0EuPoWbI2K7Bc57tIIcFLW7P0R2QjDVTUxXFF9la834p+bmTh73dSyde56Oi7cyLQauNxUTmgT5IH2wYUtXE0bcdFjogZHFE3dz3JSTV3NclOBnDtWwlix96o1aYhgClhypanFRq40/SJucUxl4/dVha/lxcoCBS1RlyxDVNaN0m9B4WJa3qB4iPJpDiicq/Hd1DJRBLQZxYJXUskQVtFuiEWpNaaQVTx4lQhlvqbQzYlayE4YrqqJ4YoaEp3BiEs3s/BXQeD6KzEd5xMzoLUSuFyUcrQJ9JBauNoHa9Dc15WTZhBRSXqtqQtcTor1ljGr792Bw02W4h5oCk4+LS1DlEdww+oSqdeaQlfWLVNrWM5t089s80/z64L9iowNLEqQmVo7zcHLpXjrWLFQpvKwbSugKJpa+ox6U92l10Yrxw3FyhhMLcZFyzipi0yQowEUatvVlWyO4aqaGK6oodMbjPj3VrYpbBVs5xIzkKsr+R9DtUKGuwJNLVztgkyhq6W/GxQMXERUWUajqZXEkG/6Zd2Qb5rIw5BfbNNZeV9rWVafb7v3RUNBV76Wli1RPi0BNX9PqDSj0bQkQtHglXPbShAr+JmbWvnPkCsLuh/6mF6LBUHHaCzy2mAlEOlLBiGjHjUe+uUqy7BVdLOYqbTYUg/mzUlVs/Vr4Biuqonhiqgkg1FE7O0sU5fCaxlSC5e1STOUTjLcFeBu0cLV0t8NKid26SAiokoy6Ewtm8WDV2mtY7ZYx64yBJlpCQSZ3DSzo/RaXvDaydSKKb2WA7rcwrX4bBHcireElRfGSoQzjn8rC8NVNTFcEVWM0SjiaoqphetcYgbOXjN1K8zMKxm4FHIB4QHuUutWu2ANWge4c+FjIiKyLV2uZcuXUW894EhBSFYsFDmZAlOpYanY8ep0PzQaTWFQWvS82OLnVrei72XANuHM2bQotcoNULqZXpt/ljhWzr7C2TEmpKkEhwlXR44cwYcffojffvsNSUlJ2LZtG4YOHVpq+ejoaHz55Zcljrdp0wbnzp2T9rds2YKZM2fi33//RfPmzbFgwQI8+uijFa4XwxVR1YmiiPjUnIIuhRnSWK703JIzZznJBLT0d0e7IA+09HdDkKczgjydEezpDF83FWcrJCIiKou5K22pQayccKbNsH2dBLmVYFbJgKYyv3avE+sRViYb2LW22dnZiIiIwMSJEzF8+PByyy9fvhzvv/++tK/X6xEREYERI0ZIx44dO4ZRo0Zh3rx5ePTRR7Ft2zaMHDkSP//8M7p06VIj90FEhQRBQJiPK8J8XPFwhyAApsB17U6uafxWYjrOFoSu1Ox8XEjKwIWkkv+4K+QC/D3UUtgK8lRL4StIY9p3V1dy3RciIqL6RCYzjcly9qza+UaDKWDlpgHaTFMrmjYLyM8s+FnaflaR8gXvmafsFw2ANt202cIrZ01jHh1EnekWKAhCuS1XxW3fvh3Dhg1DbGwswsLCAACjRo1CRkYGdu7cKZUbOHAgvLy8sGHDhgpdly1XRDVPFEUkpedJU8LHpeYgMS0XiWl5uJGRB4Ox/H+a3NVOBcHLFLYCNc4W+/4eak6sQUREVBvMXRwrHNAK9ksLdYZ803XfjDWtgWdHDtNyVV2rV69G//79pWAFmFquXn31VYtyAwYMwLJly0q9jlarhVarlfYzMmqgiZSILAiCILVEDWgbYPGe3mBEcqYWSem5uJ6WVxC6TJt5Pz1Xh8w8Pf6+kYm/b2Ra/QyZAKn1K1CjLhK8TOEr2NMZGmcFhHrWN5yIiKjWyWSm2TNtNYOmPt8UstSetrleLXHYcJWUlISdO3fim2++sTh+48YN+Pv7Wxzz9/fHjRulL/S3cOFCzJ07t0bqSUSV5ySXSSHonjDrZbK1+hLh63rBz6T0PCSl5SHfYDS9Ts8r9bOcFXKpy6FF+NKoEaBRw89DDTeVw/5TSURE5JiclICTfVusqsJhf2OIiYmBp6en1W6Exf8vtCiKZf6f6RkzZmDq1KnSfkZGBkJCQmxWVyKyPVeVE1r4uaOFn7vV941GEbeztUgsJXwlpuXidlY+cnUG/HsrG//eyi71s1yUcvi5q+Dnroavhwr+7mr4eaikY+bXbAUjIiJq2BwyXImiiDVr1mDcuHFQKi3n5Q8ICCjRSpWcnFyiNasolUoFlYqLrxHVJzKZYAo+7mrcHeJptUyeziAFLSl4peUhMT0X1+/k4kZGHnLyDcjJN+BqSg6upuSU+ZlKJxl83VSWwctdBX8PUygzH/NxVXImRCIionrIIcPV4cOHcfnyZUyaNKnEe127dsXevXstxl3t2bMH3bp1q80qEpEDUCvkaNrIFU0buZZaJkurR3JGHpIztaYtIw+3zK8z85CcYXqdnqtDvt6I6wVBrSxymYBGbkopfPl5qOBbJIiZjzVyU3FCDiIiIgdi13CVlZWFy5cvS/uxsbE4ffo0vL29ERoaihkzZuD69etYt26dxXmrV69Gly5d0K5duxLXfPnll9GzZ0988MEHGDJkCP73v/9h3759+Pnnn2v8foio/nFTOcHN1w3NfN3KLJenMxSGLimMFYav5EwtbmXmISU7HwajiJsZWtzM0JZ5TUEAvF2U8HVXwc8cugo2X3e16bi7Cr7uKrhyXBgREZHd2fW/xqdOnUKfPn2kffO4pwkTJiAmJgZJSUmIj4+3OCc9PR1btmzB8uXLrV6zW7du+Pbbb/HOO+9g5syZaN68OTZu3Mg1roioRqkVcoR4uyDE26XMcjqDESlZ+cWCVx5uZpjClymcaXE7Swu9UURKdj5SsvNLnRHRzDwuzLdg8ysIX75uKvh6mH76uavg46aCnF0SiYiIakSdWeeqLuE6V0Rkb0ajiNSc/IIAllfQ8qUtaB3LK/Jai5x8Q4WvKxMAb1eVRauXxWs3UyuZr7sKrko5J+ggIqIGr8Gsc0VEVF/JZAIauZnGXbVB2f+QZ2v1UtC6lVnYAnYrU4tbWaaWsFtZWqRkaWEUgdtZppaxC0ll18FZITeNB3OzFsbU0msfVyWcODaMiIiI4YqIyNG5qpzgqnJCkzIm5gAAg1FESrbWotXrVpEQdqsghN3K1CJLq0euzoC4lBzElTNLImAam6ZxVkibp0vBa5cix5yVFu95OCvgrnLizIlERFRvMFwRETUQ8iLT05cnJ19vNYRJXRILWsTME3RkafXI0urLnSmxOJkAeDgr4OlcGLg8XZTQODtJYaxoSPMsEtacFey2SEREdQvDFRERleCidEKYjxPCfMpvDUvP1UlbWk4+0nN1yMjVIS2n4FiR99OlY/nI0xlhFIG0HFPZylLKZQVhrGjrmEI65mkOai4KeLkoC/YVcFcrOKkHERHVCIYrIiKqMrlMgLerEt6uyvILF5OnMyDDIphZhrGMImEtrVg40xtF5BuM0vixyhAEwEOtgJeLApoiocvT2bTv5WLeNwUzT2dTOPNwZigjIqKyMVwREZFdqBVyqBVy+HmU302xKFEUkZNvMAWuHFMrWEaxgHYnpyCc5eZLLWNpOfnIzjdAFCEFOlRgPFlRHmoneLoopdYyr4LX5mAmBbWix50VnPCDiKiBYLgiIiKHIgiCNIlHsKdzpc7N1xsLglVh6Lpjbh3LKQxjpoBW8DpHh0ytHgCQkadHRp4e8amVq7O7ygkaF4VpUWqVE9zUpvq7F9xH0eMWZZROcFcXllE6MaQREdVlDFdERNRgKJ1k0hTylaEzGAtawkwtYFJrWK4O6Tn5uJNT+J4U1HLykZFnCmWZWr0U0KpVf7lMCmCF4UwON7UCbip5QTBTwFUltwhlxYObq8oJCramERHZHMMVERFRORRyGXzcVPBxq1wo0xuMyMjTmwJZrg7ZWj2ytXpk5pl+mmZZNCBLq0NWXuHrbK1BmoExK880LT4A5BuMSM3OR2p2frXvSeUkg3vB2DPzuDkvVyW8XZQl991MP52V8mp/LhFRfcZwRUREVEOc5LIqT/hRlN5gRHa+KXCVCGd5eimIZRe0kGUXO170PK3eCADQ6o3QVnJCELVCJoUtr4IQ5uWihI85iJn3C973cuF4MyJqWBiuiIiI6jgnuQwaZxk0zopqX0tnMErBLCPX1KqWkp2POzmmFrE72UX3dbhT0FKWbzAiT2dEYnoeEtPzKvx5Hmon+LiprLaQebkWCWYF+x5qJ65fRkQOi+GKiIioAVHIZQWzGSoBr4qdI4oisvMNUtAyb+ZAZm0/LVcHUSycBCS2gvWTywSonWRQKeRQOckKNjlUisLXakXBMSdZwfEiZcs4r2T5ku/LON0+EVUDwxURERGVSRAEaTKMEG+XCp1jXmC6tPB1JzsfqTmFP1OzTFPlG4ymIJedb6jhu7JOIReshjXPIi1v5lY27yJdIc2v1QqOSyNqyBiuiIiIyOaqssB0ns6A9FwdtDojtHqDaVyY3gCtzoi8gp/SMb2xWDkjtLoir4uVz9NZPy9PZ4BRLKyDziBCZ9CjkmtTS5wV8mLdHxXwdlXB21VhtTukJ9dBI6pXGK6IiIioTjAvLF3b9AZjqaFMqzeaFq2WWtl0Ft0jpbFqOfnQGUTk6gy4npaL62m5Ff58jbNCClumVjBFYQBzKQxq5jLuKo5LI6qrGK6IiIioQXOSy+Akl8G1cjPtWxBFEZlavRS8zBOCpGZrCycGMQe0gtdpOToAKFjYWgfczq5YfWUCvFyVcFM5wVkhh6tKDmelE1wUcrgo5XBRyeGiNL1n2i98z1kph6uqyHtKJ1N5hZwtaEQ2wHBFREREVE2CIMBDrYCHWoEwH9cKnaM3GJGeq8OdnHykZBWZobGUiULuZJvGpemNIm5lanErs4p9F0uhlMtM4asghLkonaR982spkCmLhLUi75kXt5YWu1Y6cZIQalAYroiIiIjswKnI4tQt/Cp2Tp7OIIWtnHyDadPqTT91BuTm65GtNSBXZ0BOfsFxbeF70jlFXhsKBp3lG4zIzzUFPlsyT4bipnYqDF9FApi7OYgVeW1+312lKDhPDpUTJwuhuo/hioiIiMhBqBVyBGqcEahxtsn1RFFEvsGIXCl0FQYv87HsfL302hzQsou8ztUZkK3VS2Wz8kwLVusLQpt5IWtkVK+uSrlMCmSF4csUysyvi4c2V5WT1NLmXKRrpDO7QVINYbgiIiIiaqAEwTz1vByeFZtlv0JEUYRWX7hgdWae6WdWwc9Mrd70Xl7R93VSmaLvm6flzzcYpa6StmDuBlk8dJm7OJpeOxV5Lbd4bTrPyeIaLko51EqOYWvIGK6IiIiIyKYEQZBmf/Rxq8ZMIUDB2meWQcwc2sxBLKtoONMakJWnk8qaW9dyC1rlzFPv11Q3SDOlXAa1Qia1nKmthDjngu9IOqYwhTPza2elzPR+KWUUDHB1DsMVEREREdVZclnhZCHVZa0bZJ6usDtk4WuDldf6Uo5blrEIbwYjMvL01a53aZxkQolAZnotkwKZFM6K7xcLdwq5ALkgQC4TIJMVeV3wUy6D9LrwWJHXggCZDFaONawJTRiuiIiIiKhBqKlukGbm7pDWA1hheDO3pOXpzK+NyNUV7JvfL7Zf9LU5wOmNpiUAMrU1F+BswSJ8FQSuouGrMNShxLH1k7tUu/WzNjFcERERERHZQNHukDUR3oDC1re8gkCWWyR0aXUGi2MVDW85+QboDEYYRBFGo1jw09Qls+gxg7HY+wXHymMwijBABAxVuN8qfEf2xHBFREREROQgira+aVD9rpK2YBG+Cn5KW5EgZrQ4VjSwocT55vdt0R20NjFcERERERFRlclkAmQQoOBSZOAUI0RERERERDbAcEVERERERGQDDFdEREREREQ2wHBFRERERERkAwxXRERERERENsBwRUREREREZAMMV0RERERERDZg13B15MgRREVFISgoCIIgYPv27eWeo9Vq8fbbbyMsLAwqlQrNmzfHmjVrLMosW7YM4eHhcHZ2RkhICF599VXk5eXV0F0QERERERHZeRHh7OxsREREYOLEiRg+fHiFzhk5ciRu3ryJ1atXo0WLFkhOToZer5feX79+PaZPn441a9agW7du+OeffxAdHQ0AWLp0aU3cBhERERERkX3DVWRkJCIjIytcfteuXTh8+DCuXLkCb29vAECTJk0syhw7dgzdu3fHmDFjpPdHjx6NEydO2KzeRERERERExTnUmKvvv/8enTt3xqJFixAcHIxWrVrh9ddfR25urlTmgQcewG+//SaFqStXrmDHjh0YPHhwqdfVarXIyMiw2IiIiIiIiCrDri1XlXXlyhX8/PPPUKvV2LZtG27fvo3nn38eqamp0rirxx9/HLdu3cIDDzwAURSh1+vx3HPPYfr06aVed+HChZg7d25t3QYREREREdVDDtVyZTQaIQgC1q9fj/vuuw+DBg3CkiVLEBMTI7VeHTp0CAsWLMCnn36K33//HVu3bsUPP/yAefPmlXrdGTNmID09XdoSEhJq65aIiIiIiKiecKiWq8DAQAQHB0Oj0UjH7rrrLoiiiGvXrqFly5aYOXMmxo0bh8mTJwMA2rdvj+zsbDz99NN4++23IZOVzJMqlQoqlarW7oOIiIiIiOofhwpX3bt3x6ZNm5CVlQU3NzcAwD///AOZTIbGjRsDAHJyckoEKLlcDlEUIYpihT7HXI5jr4iIiIiIGjZzJqhIlrBruMrKysLly5el/djYWJw+fRre3t4IDQ3FjBkzcP36daxbtw4AMGbMGMybNw8TJ07E3Llzcfv2bbzxxht48skn4ezsDACIiorCkiVL0LFjR3Tp0gWXL1/GzJkz8cgjj0Aul1eoXpmZmQCAkJAQG98xERERERE5oszMTIsedNYIYkWbc2rAoUOH0KdPnxLHJ0yYgJiYGERHR+Pq1as4dOiQ9N7ff/+NF198Eb/88gt8fHwwcuRIzJ8/XwpXer0eCxYswFdffYXr16/D19cXUVFRWLBgATw9PStUL6PRiMTERLi7u0MQBFvcKpUiIyMDISEhSEhIgIeHh72r0yDwO699/M5rF7/v2sfvvPbxO69d/L5rX136zkVRRGZmJoKCgqwOMSrKruGKKCMjAxqNBunp6Xb/i9NQ8DuvffzOaxe/79rH77z28TuvXfy+a5+jfucONVsgERERERFRXcVwRUREREREZAMMV2RXKpUKs2fP5lT4tYjfee3jd167+H3XPn7ntY/fee3i9137HPU755grIiIiIiIiG2DLFRERERERkQ0wXBEREREREdkAwxUREREREZENMFwRERERERHZAMMV1ZiFCxfi3nvvhbu7O/z8/DB06FBcvHixzHMOHToEQRBKbH///Xct1dqxzZkzp8R3FxAQUOY5hw8fxj333AO1Wo1mzZrhs88+q6Xa1g9NmjSx+sxOmTLFank+45Vz5MgRREVFISgoCIIgYPv27Rbvi6KIOXPmICgoCM7OzujduzfOnTtX7nW3bNmCNm3aQKVSoU2bNti2bVsN3YHjKes71+l0mDZtGtq3bw9XV1cEBQVh/PjxSExMLPOaMTExVp/7vLy8Gr4bx1Decx4dHV3iu7v//vvLvS6fc+vK+76tPauCIODDDz8s9Zp8xstWkd8J68u/5wxXVGMOHz6MKVOm4Pjx49i7dy/0ej0eeughZGdnl3vuxYsXkZSUJG0tW7ashRrXD23btrX47s6ePVtq2djYWAwaNAg9evTAH3/8gbfeegsvvfQStmzZUos1dmwnT560+L737t0LABgxYkSZ5/EZr5js7GxERERgxYoVVt9ftGgRlixZghUrVuDkyZMICAjAgw8+iMzMzFKveezYMYwaNQrjxo3DmTNnMG7cOIwcORK//vprTd2GQynrO8/JycHvv/+OmTNn4vfff8fWrVvxzz//4JFHHin3uh4eHhbPfFJSEtRqdU3cgsMp7zkHgIEDB1p8dzt27CjzmnzOS1fe9138OV2zZg0EQcDw4cPLvC6f8dJV5HfCevPvuUhUS5KTk0UA4uHDh0stc/DgQRGAeOfOndqrWD0ye/ZsMSIiosLl33zzTbF169YWx5555hnx/vvvt3HNGo6XX35ZbN68uWg0Gq2+z2e86gCI27Ztk/aNRqMYEBAgvv/++9KxvLw8UaPRiJ999lmp1xk5cqQ4cOBAi2MDBgwQH3/8cZvX2dEV/86tOXHihAhAjIuLK7XM2rVrRY1GY9vK1VPWvvMJEyaIQ4YMqdR1+JxXTEWe8SFDhoh9+/Ytswyf8cop/jthffr3nC1XVGvS09MBAN7e3uWW7dixIwIDA9GvXz8cPHiwpqtWr1y6dAlBQUFo2rQpHn/8cVy5cqXUsseOHcNDDz1kcWzAgAE4deoUdDpdTVe13snPz8fXX3+NJ598EoIglFmWz3j1xcbG4saNGxbPsEqlQq9evXD06NFSzyvtuS/rHCpdeno6BEGAp6dnmeWysrIQFhaGxo0b4+GHH8Yff/xROxWsJw4dOgQ/Pz+0atUKTz31FJKTk8ssz+fcNm7evIkff/wRkyZNKrcsn/GKK/47YX3695zhimqFKIqYOnUqHnjgAbRr167UcoGBgfj888+xZcsWbN26FeHh4ejXrx+OHDlSi7V1XF26dMG6deuwe/durFq1Cjdu3EC3bt2QkpJitfyNGzfg7+9vcczf3x96vR63b9+ujSrXK9u3b0daWhqio6NLLcNn3HZu3LgBAFafYfN7pZ1X2XPIury8PEyfPh1jxoyBh4dHqeVat26NmJgYfP/999iwYQPUajW6d++OS5cu1WJtHVdkZCTWr1+PAwcOYPHixTh58iT69u0LrVZb6jl8zm3jyy+/hLu7O4YNG1ZmOT7jFWftd8L69O+5k90+mRqUF154AX/++Sd+/vnnMsuFh4cjPDxc2u/atSsSEhLw0UcfoWfPnjVdTYcXGRkpvW7fvj26du2K5s2b48svv8TUqVOtnlO8hUUURavHqXyrV69GZGQkgoKCSi3DZ9z2rD3D5T2/VTmHLOl0Ojz++OMwGo349NNPyyx7//33W0zA0L17d3Tq1Akff/wx/vOf/9R0VR3eqFGjpNft2rVD586dERYWhh9//LHMX/r5nFffmjVrMHbs2HLHTvEZr7iyfiesD/+es+WKatyLL76I77//HgcPHkTjxo0rff7999/P//NTRa6urmjfvn2p319AQECJ/7uTnJwMJycn+Pj41EYV6424uDjs27cPkydPrvS5fMarxjwTprVnuPj/ySx+XmXPIUs6nQ4jR45EbGws9u7dW2arlTUymQz33nsvn/sqCgwMRFhYWJnfH5/z6vvpp59w8eLFKv27zmfcutJ+J6xP/54zXFGNEUURL7zwArZu3YoDBw6gadOmVbrOH3/8gcDAQBvXrmHQarW4cOFCqd9f165dpdntzPbs2YPOnTtDoVDURhXrjbVr18LPzw+DBw+u9Ll8xqumadOmCAgIsHiG8/PzcfjwYXTr1q3U80p77ss6hwqZg9WlS5ewb9++Kv2PGFEUcfr0aT73VZSSkoKEhIQyvz8+59W3evVq3HPPPYiIiKj0uXzGLZX3O2G9+vfcPvNoUEPw3HPPiRqNRjx06JCYlJQkbTk5OVKZ6dOni+PGjZP2ly5dKm7btk38559/xL/++kucPn26CEDcsmWLPW7B4bz22mvioUOHxCtXrojHjx8XH374YdHd3V28evWqKIolv+8rV66ILi4u4quvviqeP39eXL16tahQKMTNmzfb6xYcksFgEENDQ8Vp06aVeI/PePVkZmaKf/zxh/jHH3+IAMQlS5aIf/zxhzQz3fvvvy9qNBpx69at4tmzZ8XRo0eLgYGBYkZGhnSNcePGidOnT5f2f/nlF1Eul4vvv/++eOHCBfH9998XnZycxOPHj9f6/dVFZX3nOp1OfOSRR8TGjRuLp0+ftvi3XavVStco/p3PmTNH3LVrl/jvv/+Kf/zxhzhx4kTRyclJ/PXXX+1xi3VOWd95Zmam+Nprr4lHjx4VY2NjxYMHD4pdu3YVg4OD+ZxXUXn/roiiKKanp4suLi7iypUrrV6Dz3jlVOR3wvry7znDFdUYAFa3tWvXSmUmTJgg9urVS9r/4IMPxObNm4tqtVr08vISH3jgAfHHH3+s/co7qFGjRomBgYGiQqEQg4KCxGHDhonnzp2T3i/+fYuiKB46dEjs2LGjqFQqxSZNmpT6HxIq3e7du0UA4sWLF0u8x2e8esxT1xffJkyYIIqiafre2bNniwEBAaJKpRJ79uwpnj171uIavXr1ksqbbdq0SQwPDxcVCoXYunVrhtsiyvrOY2NjS/23/eDBg9I1in/nr7zyihgaGioqlUrR19dXfOihh8SjR4/W/s3VUWV95zk5OeJDDz0k+vr6igqFQgwNDRUnTJggxsfHW1yDz3nFlffviiiK4n//+1/R2dlZTEtLs3oNPuOVU5HfCevLv+eCKBaMXiciIiIiIqIq45grIiIiIiIiG2C4IiIiIiIisgGGKyIiIiIiIhtguCIiIiIiIrIBhisiIiIiIiIbYLgiIiIiIiKyAYYrIiIiIiIiG2C4IiIiIiIisgGGKyIiIhsTBAHbt2+3dzWIiKiWMVwREVG9Eh0dDUEQSmwDBw60d9WIiKiec7J3BYiIiGxt4MCBWLt2rcUxlUplp9oQEVFDwZYrIiKqd1QqFQICAiw2Ly8vAKYueytXrkRkZCScnZ3RtGlTbNq0yeL8s2fPom/fvnB2doaPjw+efvppZGVlWZRZs2YN2rZtC5VKhcDAQLzwwgsW79++fRuPPvooXFxc0LJlS3z//fc1e9NERGR3DFdERNTgzJw5E8OHD8eZM2fwxBNPYPTo0bhw4QIAICcnBwMHDoSXlxdOnjyJTZs2Yd++fRbhaeXKlZgyZQqefvppnD17Ft9//z1atGhh8Rlz587FyJEj8eeff2LQoEEYO3YsUlNTa/U+iYiodgmiKIr2rgQREZGtREdH4+uvv4ZarbY4Pm3aNMycOROCIODZZ5/FypUrpffuv/9+dOrUCZ9++ilWrVqFadOmISEhAa6urgCAHTt2ICoqComJifD390dwcDAmTpyI+fPnW62DIAh45513MG/ePABAdnY23N3dsWPHDo79IiKqxzjmioiI6p0+ffpYhCcA8Pb2ll537drV4r2uXbvi9OnTAIALFy4gIiJCClYA0L17dxiNRly8eBGCICAxMRH9+vUrsw4dOnSQXru6usLd3R3JyclVvSUiInIADFdERFTvuLq6luimVx5BEAAAoihKr62VcXZ2rtD1FApFiXONRmOl6kRERI6FY66IiKjBOX78eIn91q1bAwDatGmD06dPIzs7W3r/l19+gUwmQ6tWreDu7o4mTZpg//79tVpnIiKq+9hyRURE9Y5Wq8WNGzcsjjk5OaFRo0YAgE2bNqFz58544IEHsH79epw4cQKrV68GAIwdOxazZ8/GhAkTMGfOHNy6dQsvvvgixo0bB39/fwDAnDlz8Oyzz8LPzw+RkZHIzMzEL7/8ghdffLF2b5SIiOoUhisiIqp3du3ahcDAQItj4eHh+PvvvwGYZvL79ttv8fzzzyMgIADr169HmzZtAAAuLi7YvXs3Xn75Zdx7771wcXHB8OHDsWTJEulaEyZMQF5eHpYuXYrXX38djRo1wmOPPVZ7N0hERHUSZwskIqIGRRAEbNu2DUOHDrV3VYiIqJ7hmCsiIiIiIiIbYLgiIiIiIiKyAY65IiKiBoW94YmIqKaw5YqIiIiIiMgGGK6IiIiIiIhsgOGKiIiIiIjIBhiuiIiIiIiIbIDhioiIiIiIyAYYroiIiIiIiGyA4YqIiIiIiMgGGK6IiIiIiIhs4P8Buu3DsvUoL0QAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import os\n",
    "os.environ['KMP_DUPLICATE_LIB_OK']='True'\n",
    "# Calculate and print accuracies for training and cross-validation sets\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    # Training set accuracy\n",
    "    tr_correct = 0\n",
    "    tr_total = 0\n",
    "    for images, labels in trLoader:\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        _, true_labels = torch.max(labels, 1)\n",
    "        tr_total += labels.size(0)\n",
    "        tr_correct += (predicted == true_labels).sum().item()\n",
    "    \n",
    "    tr_accuracy = 100 * tr_correct / tr_total\n",
    "    \n",
    "    # Cross-validation set accuracy\n",
    "    cv_correct = 0\n",
    "    cv_total = 0\n",
    "    for images, labels in cvLoader:\n",
    "        outputs = model(images)\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        _, true_labels = torch.max(labels, 1)\n",
    "        cv_total += labels.size(0)\n",
    "        cv_correct += (predicted == true_labels).sum().item()\n",
    "    \n",
    "    cv_accuracy = 100 * cv_correct / cv_total\n",
    "\n",
    "print(f'Accuracy on training set: {tr_accuracy:.2f}%')\n",
    "print(f'Accuracy on cross-validation set: {cv_accuracy:.2f}%')\n",
    "\n",
    "# Plot training and cross-validation losses\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(range(1, num_epochs+1), train_losses, label='Training Loss')\n",
    "plt.plot(range(1, num_epochs+1), cv_losses, label='Cross-Validation Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training and Cross-Validation Loss')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f66b824-238d-44b8-829e-acf4e5eb408c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
